名域 ts {
    导出 接口 词典族_<T> {
        [i: 文字]: T
    }

    /* @internal */
    导出 类型 相等比较器_<T> = (a: T, b: T) => 真假;

    /* @internal */
    导出 类型 比较器_<T> = (a: T, b: T) => 比较结果_;

    /* @internal */
    导出 常量 枚举 比较结果_ {
        小于_ = -1,
        等于_ = 0,
        大于_ = 1
    }

    导出 接口 迭代器结果_<T> {
        done: 真假;
        value: T;
    }

    导出 接口 数值范围_{
        最大: 数字
        最小: 数字
    }

    导出 接口 迭代器_<T> {
        next(值?: 任意): 迭代器结果_<T>;
        return?(值?: 任意): 迭代器结果_<T>;
        throw?(e?: 任意): 迭代器结果_<T>;
    }

    // branded string 类型 used to store absolute, normalized and canonicalized paths
    // arbitrary 文件 名称 can be converted to 路径_ via toPath function
    导出 类型 路径_ = 文字 & { __路径支持: 任意 };

    导出 接口 文本范围_ {
        首位: 数字;
        尾位: 数字;
    }

    导出 类型 JsDoc语法_ = | 语法_.文件结尾令牌_ | 语法_.空白杂项_ | 语法_.艾特号_ | 语法_.新行杂项_ | 语法_.星号_
        | 语法_.左大括号_ | 语法_.右大括号_ | 语法_.左尖号_ | 语法_.左方括号_ | 语法_.右方括号_ | 语法_.等号_
        | 语法_.逗号_ | 语法_.点号_ | 语法_.标识符_ | 语法_.未知_
        ;

    // 令牌 > 语法_.Identifer => 令牌 is a keyword
    // Also, If you add a new 语法_ be sure to keep the `Markers` section at the bottom in sync
    导出 常量 枚举 语法_ {
        未知_,
        文件结尾令牌_,
        单行注释杂项_,
        多行注释杂项_,
        新行杂项_,
        空白杂项_,
        // We detect and preserve #! on the 首个 line
        指令杂项_,
        // We detect and provide better error recovery when we encounter a git merge marker.  This
        // allows us to edit files with git-conflict markers in them in a much more pleasant manner.
        冲突标记杂项_,
        // Literals
        数字字面量_,
        文本字面量_,
        字符字面量_,
        正则表达式字面量_,
        无替换模板字面量_,
        // Pseudo-literals
        模板头_,
        模板中_,
        模板尾_,
        // Punctuation
        /* { */
        左大括号_,
        /* } */
        右大括号_,
        /* ( */
        左括号_,
        /* ) */
        右括号_,
        /* [ */
        左方括号_,
        /* ?[ */
        问左方括号_,
        /* ] */
        右方括号_,
        /* . */
        点号_,
        /* ... */
        三点号_,
        /* ; */
        分号_,
        /* , */
        逗号_,
        /*< */
        左尖号_,
        /* > */
        右尖号_,
        /* <= */
        左尖等号_,
        /* >= */
        右尖等号_,
        /* == */
        双等号_,
        /* != */
        叹号等号_,
        /* => */
        等右尖号_,
        /* =>: */
        等右尖冒号_,
        /* + */
        加号_,
        /* - */
        减号_,
        /* * */
        星号_,
        /* / */
        斜杠号_,
        /* % */
        百分号_,
        /* ++ */
        双加号_,
        /* -- */
        双减号_,
        /* << */
        双左尖号_,
        /* >> */
        双右尖号_,
        /* & */
        且号_,
        /* | */
        或号_,
        /* ^ */
        异或号_,
        /* ! */
        叹号_,
        /* ~ */
        波折号_,
        /* && */
        双且号_,
        /* || */
        双或号_,
        /* ? */
        问号_,
        /* ?. */
        问点号_,
        /* : */
        冒号_,
        /* :> */
        冒右尖号_,
        /* @ */
        艾特号_,

        // Assignments
        /* = */
        等号_,
        /* := */
        冒等号_,
        /* -> */
        减右尖号_,
        /* <- */
        左尖减号_,
        /* += */
        加等号_,
        /* -= */
        减等号_,
        /* *= */
        星等号_,
        /* /= */
        斜杠等号_,
        /* %= */
        百分等号_,
        /* <<= */
        双左尖等号_,
        /* >>= */
        双右尖等号_,
        /* &= */
        且等号_,
        /* |= */
        或等号_,
        /* ^= */
        异或等号_,
        // Identifiers
        标识符_,
        // Reserved words
        变量_,
        从_,
        程序_,
        常量_,
        创建_,
        导入_,
        返回_,
        否则_,
        方法_,
        范围_,
        贯穿_,
        函数_,
        接口_,
        枚举_,
        假如_,
        继续_,
        结构_,
        类型_,
        另如_,
        默认_,
        若是_,
        如果_,
        属于_,
        删除_,
        执行_,
        善后_,
        跳出_,
        调试_,
        位于_,
        循环_,
        启动_,
        初始_,
        选择_,
        新建_,
        真_,
        假_,
        // 内置类型关键字
        真假_,
        通用_,
        列表_,
        词典_,
        未定_,
        无值_,
        文本_,
        整数_,
        整数8_,
        整数16_,
        整数32_,
        整数64_,
        正整数_,
        正整数8_,
        正整数16_,
        正整数32_,
        正整数64_,
        小数_,
        小数32_,
        小数64_,
        复数64_,
        复数128_,
        指针_,
        字符_,
        字节_,
        预_定义_,
        预_完成定义_,
        __win__,
        __linux__,
        __darwin__,
        __386__,
        __amd64__,
        __arm__,
        // Parse tree nodes
        // Names
        限定名_,
        参数_,
        接受者声明_,
        // TypeMember
        属性声明_,
        方法签名_,
        方法声明_,
        // 类型_
        类型引用_,
        条件类型_,
        三元类型_,
        函数类型_,
        数组类型_,
        变长参数类型_,
        列表类型_,
        词典类型_,
        联合类型_,
        交叉类型_,
        指针类型_,
        通信类型_,
        只读通信_,
        只写通信_,
        括号类型_,

        // 表达式_
        数组字面量表达式_,
        列表字面量表达式_,
        数组或列表字面量表达式_,
        词典字面量表达式_,
        词典键值表达式_,
        表达式包括类型参数_,
        结构字面量表达式_,
        结构字面量成员表达式_,

        属性访问表达式_,
        元素访问表达式_,
        调用表达式_,
        新建表达式_,
        创建表达式_,
        标记模板表达式_,
        类型断言表达式_,
        括号表达式_,
        函数表达式_,
        箭头函数_,
        无值表达式_,
        前缀一元表达式_,
        取址表达式_,
        取值表达式_,
        后缀一元表达式_,
        后缀读信道表达式_,
        写入通信表达式_,
        二元表达式_,
        条件表达式_,
        模板表达式_,
        展开元素_,
        省略表达式_,
        类型转换表达式_,
        类型查询表达式_,
        // Misc
        模板跨度_,
        // Element
        块_,
        空语句_,
        程序声明_,
        变量语句_,
        简洁变量语句_,
        常量语句_,
        常量列表语句_,
        表达式语句_,
        如果语句_,
        另如语句_,
        循环语句_,
        循环属于语句_,
        删除语句_,
        执行语句_,
        善后语句_,
        继续语句_,
        跳出语句_,
        贯穿语句_,
        返回语句_,
        假如语句_,
        选择语句_,
        标签语句_,
        调试语句_,
        变量声明_,
        常量列表元素_,
        常量声明_,
        函数声明_,
        函数签名_,
        创建函数签名_,
        启动函数声明_,
        初始函数声明_,
        接口声明_,
        枚举声明_,
        枚举成员声明_,
        结构声明_,
        结构声明属性组_,
        返回值声明属性组_,
        类型别名声明_,
        类型声明_,
        类型参数声明_,

        若是块_,
        导入声明_,
        导入成员_,
        导入从声明_,
        导入从成员_,
        失踪声明_,

        // Clauses
        若是子句_,
        默认子句_,

        // Top-level nodes
        源文件_,
        源文件集_,
        模块_,

        JsDoc注释_,
        JSDoc标签_,

        // Synthesized 列表
        语法列表_,

        // Transformation nodes
        不输出语句_,
        部分输出表达式_,
        逗号列表表达式_,
        合并声明标记_,
        声明结束标志_,

        // Enum value count
        计数_,

        // Markers
        首赋值_ = 等号_,
        尾赋值_ = 异或等号_,
        首复合赋值_ = 加等号_,
        尾复合赋值_ = 异或等号_,
        首保留_ = 变量_,
        尾保留_ = 字节_,
        首关键字_ = 变量_,
        尾关键字_ = 字节_,

        首预处理变量_ = __win__,
        首预处理系统变量_ = 首预处理变量_,
        尾预处理系统变量_ = __darwin__,
        首预处理架构变量_ = __386__,
        尾预处理架构变量_ = __arm__,
        尾预处理变量_ = 尾预处理架构变量_,

        首类型节点_ = 类型引用_,
        尾类型节点_ = 括号类型_,
        首标点_ = 左大括号_,
        尾标点_ = 异或等号_,
        首令牌_ = 未知_,
        尾令牌_ = __arm__,
        首杂项令牌_ = 单行注释杂项_,
        尾杂项令牌_ = 冲突标记杂项_,
        首字面量令牌_ = 数字字面量_,
        尾字面量令牌_ = 无替换模板字面量_,
        首模板令牌_ = 无替换模板字面量_,
        尾模板令牌_ = 模板尾_,
        首二元运算符_ = 左尖号_,
        尾二元运算符_ = 异或等号_,
        首节点_ = 限定名_,
        首JsDoc节点_ = JsDoc注释_,
        尾JsDoc节点_ = JSDoc标签_,
        首JsDoc标签节点_ = JSDoc标签_,
        尾JsDoc标签节点_ = JSDoc标签_
    }

    导出 常量 枚举 节点标志_ {
        无_ = 0,
        变量_ = 1 << 0,  // Variable declaration
        常量_ = 1 << 1,  // Variable declaration
        合成的_ = 1 << 2,  // 节点_ was synthesized during transformation
        具有隐式返回_ = 1 << 3,  // If function implicitly returns on one of codepaths (initialized by binding)
        具有显示返回_ = 1 << 4,  // If function has explicit reachable return on one of codepaths (initialized by binding)   
        这个节点有错误_ = 1 << 6, // If the parser encountered an error when parsing the code that created this n

        Klang文件_ = 1 << 7, // If n was parsed in a JavaScript
        // This flag will be set when the parser encounters a dynamic import 表达式 so that module resolution
        // will not have to walk the tree if the flag is not set. However, this flag is just a approximation because
        // once it is set, the flag never gets cleared (hence why it's named '可能包含动态导入_').
        // During editing, if dynamic import is removed, incremental parsing will *NOT* update this flag. This means that the tree will always be traversed
        // during module resolution. However, the removal operation should not occur often and in the case of the
        // removal, it is likely that users will add the import anyway.
        // The advantage of this approach is its simplicity. For the case of batch compilation,
        // we guarantee that users won't have to pay the price of walking the tree if a dynamic import isn't used.
        /* @internal */
        可能包含动态导入_ = 1 << 8,

        JSDoc = 1 << 9, // If n was parsed inside jsdoc
        /* @internal */ 环境_ = 1 << 10, // If n was inside an ambient 上下文 -- a declaration 文件, or inside something with the `declare` 修饰符.
        具有聚合子数据_ = 1 << 12,
        是匿名属性转换的  = 1 << 13,
        是私有的_ = 1 << 27,        
        是空标识符_ = 1 << 28,
        块范围检测_ = 变量_ | 常量_,
        可达性检测标志_ = 具有隐式返回_ | 具有显示返回_,
        下文标志_ = Klang文件_ | 环境_,
    }

    导出 常量 枚举 修饰符组_ {
        无_ = 0,
        导出_ = 1 << 0,  // Declarations
        Ambient = 1 << 1,  // Declarations
        Public = 1 << 2,  // Property/Method
        Private = 1 << 3,  // Property/Method
        Protected = 1 << 4,  // Property/Method
        Static = 1 << 5,  // Property/Method
        Readonly = 1 << 6,  // Property/Method
        Abstract = 1 << 7,  // Class/Method/构造签名_
        异步_ = 1 << 8,  // Property/Method/函数_
        默认_ = 1 << 9,  // 函数_/Class (export 默认 declaration)
        常量_ = 1 << 11, // Variable declaration
        是私有的_ = 1 << 27,        
        是空标识符_ = 1 << 28,
        具有计算标志_ = 1 << 29,
        AccessibilityModifier = Public | Private | Protected,
        // Accessibility 修饰符 and 'readonly' can be attached to a 参数 in a constructor to make it a property.
        ParameterPropertyModifier = AccessibilityModifier | Readonly,
        NonPublicAccessibilityModifier = Private | Protected,

        TypeScriptModifier = Ambient | Public | Private | Protected | Readonly | Abstract | 常量_,
        ExportDefault = 导出_ | 默认_,
    }

    /* @internal */
    导出 常量 枚举 关系比较结果_ {
        成功的_ = 1, // Should be truthy
        失败的_ = 2,
        失败并报告_ = 3
    }

    导出 接口 节点_ 扩展 文本范围_ {
        种类: 语法_;
        标志: 节点标志_;
        /* @internal */ 修饰符标志缓存?: 修饰符组_;
        /* @internal */ id?: 数字;                          // Unique id (used to look up NodeLinks)
        父节点: 节点_;                                        // Parent n (initialized by binding)
        /* @internal */ 原始?: 节点_;                      // The 原始 n if this is an updated n.
        /* @internal */ 符号: 符号_;                      // 符号_ declared by n (initialized by binding)
        /* @internal */ 本地组?: 符号表_;                 // Locals associated with n (initialized by binding)
        /* @internal */ 下个容器?: 节点_;                 // Next container in declaration order (initialized by binding)
        /* @internal */ 本地符号?: 符号_;                 // Local 符号 declared by n (initialized by binding only for exported nodes)
        /* @internal */ 流程节点?: 流程节点_;                  // Associated 流程节点_ (initialized by binding)
        /* @internal */ 输出节点?: 输出节点_;                  // Associated 输出节点_ (initialized by transforms)
        /* @internal */ 上下文类型_?: 类型_;                // Used to temporarily assign a contextual 类型 during overload resolution
        /* @internal */ contextualMapper?: 类型映射_;        // Mapper for contextual type
    }

    导出 接口 JSDoc容器_ {
        /* @internal */ jsDoc?: JSDoc_[];                      // JSDoc that directly precedes this n
        /* @internal */ jsDoc缓存_?: 只读数组_<JSDoc标签_>; // Cache for getJSDocTags
    }

    导出 类型 有JSDoc_ =
        | 程序声明_
        | 导入声明_
        | 导入从声明_
        | 导入从成员_
        | 导入成员_
        | 参数声明_
        | 接受者声明_
        | 方法签名_        
        | 函数签名族_
        | 箭头函数_
        | 括号表达式_
        | 标签语句_
        | 函数表达式_
        | 表达式语句_
        | 常量语句_
        | 常量声明_
        | 常量列表语句_
        | 常量列表元素_
        | 变量语句_
        | 函数声明_
        | 方法声明_
        | 属性声明_
        | 接口声明_
        | 枚举声明_
        | 枚举成员声明_
        | 类型声明_
        | 类型别名声明_
        | 函数类型节点_
        | 结构声明属性组_
        | 文件结尾令牌_
        ;

    导出 类型 有类型_ =
        | 签名声明_ | 变量声明_ | 参数声明_ | 属性声明_
        | 括号类型节点_ | 断言表达式_ | 类型别名声明_
        ;

    导出 类型 有初始化_ =
        | 有表达式初始化_
        | 循环语句_
        | 循环属于语句_
        ;

    导出 类型 有表达式初始化_ =
        | 变量声明_
        ;

    /* @internal */
    导出 类型 多维节点数组_<T 扩展 节点_> = 节点数组_<T> & T[];

    导出 接口 节点数组_<T 扩展 节点_> 扩展 只读数组_<T>, 文本范围_ {
        有尾随逗号?: 真假;
    }

    导出 接口 令牌_<T种类_ 扩展 语法_> 扩展 节点_ {
        种类: T种类_;
    }

    导出 类型 三点号_ = 令牌_<语法_.三点号_>;
    导出 类型 问号_ = 令牌_<语法_.问号_>;
    导出 类型 叹号_ = 令牌_<语法_.叹号_>;
    导出 类型 冒号_ = 令牌_<语法_.冒号_>;
    导出 类型 等号_ = 令牌_<语法_.等号_>;
    导出 类型 冒等号_ = 令牌_<语法_.冒等号_>;
    导出 类型 星号_ = 令牌_<语法_.星号_>;
    导出 类型 等右尖号_ = 令牌_<语法_.等右尖号_>;
    导出 类型 等右尖冒号_ = 令牌_<语法_.等右尖冒号_>;    
    导出 类型 文件结尾令牌_ = 令牌_<语法_.文件结尾令牌_> & JSDoc容器_;
    导出 类型 艾特号_ = 令牌_<语法_.艾特号_>;
    导出 类型 加号_ = 令牌_<语法_.加号_>;
    导出 类型 减号_ = 令牌_<语法_.减号_>;

    /*@internal*/
    导出 常量 枚举 自动的标识符标志_ {
        // Kinds
        无_ = 0,                           // Not automatically generated.
        Auto = 1,                           // Automatically generated 标识符.
        Loop = 2,                           // Automatically generated 标识符 with a preference for '_i'.
        Unique = 3,                         // Unique 名称 based on the '文本' property.
        节点_ = 4,                           // Unique 名称 based on the n in the '原始' property.
        KindMask = 7,                       // Mask to extract the 种类 of 标识符 from its 标志.

        // Flags
        SkipNameGenerationScope = 1 << 3,   // Should skip a 名称 generation scope when generating the 名称 for this 标识符
        ReservedInNestedScopes = 1 << 4,    // Reserve the generated 名称 in nested scopes
    }

    导出 接口 标识符_ 扩展 基本表达式_, 声明_ {
        种类: 语法_.标识符_;
        /**
         * Prefer to use `id.unescapedText`. (Note: This is available only in services, not internally to the TypeScript compiler.)
         * Text of 标识符, but if the 标识符 begins with two underscores, this will begin with three.
         */
        文本: 文字;
        原始关键字种类?: 语法_;                         // Original syntaxKind which get set so that we can report an error later
        /*@internal*/ 类型实参?: 节点数组_<类型节点_ | 类型参数声明_>;
        /*@internal*/ 自动标志?: 自动的标识符标志_; // Specifies whether to auto-generate the 文本 for an 标识符.
        /*@internal*/ 自动Id?: 数字;                    // Ensures unique generated 标识符组 get unique names, but clones get the same 名称.
        是在JSDoc名域?: 真假;
    }

    // Transient 标识符 n (marked by id === -1)
    导出 接口 瞬态标识符_ 扩展 标识符_ {
        解析的符号: 符号_;
    }

    /*@internal*/
    导出 接口 自动标识符_ 扩展 标识符_ {
        自动标志: 自动的标识符标志_;
    }

    导出 接口 限定名_ 扩展 节点_ {
        种类: 语法_.限定名_;
        左侧: 实体名称_;
        右侧: 标识符_
    }

    导出 类型 内置类型令牌_ =
        | 令牌_<语法_.真假_>
        | 令牌_<语法_.通用_>
        | 令牌_<语法_.整数_>
        | 令牌_<语法_.整数8_>
        | 令牌_<语法_.整数16_>
        | 令牌_<语法_.整数32_>
        | 令牌_<语法_.整数64_>
        | 令牌_<语法_.正整数_>
        | 令牌_<语法_.正整数8_>
        | 令牌_<语法_.正整数16_>
        | 令牌_<语法_.正整数32_>
        | 令牌_<语法_.正整数64_>
        | 令牌_<语法_.小数_>
        | 令牌_<语法_.小数32_>
        | 令牌_<语法_.小数64_>
        | 令牌_<语法_.复数64_>
        | 令牌_<语法_.复数128_>
        | 令牌_<语法_.字节_>
        | 令牌_<语法_.字符_>
        | 令牌_<语法_.文本_>
        | 令牌_<语法_.无值_>
        | 令牌_<语法_.未定_>
        ;

    导出 类型 实体名称_ = 标识符_ | 限定名_;

    导出 类型 名称_ = 实体名称_ | 内置类型令牌_;

    导出 接口 声明_ 扩展 节点_ {
        _声明支持: 任意;
    }

    导出 接口 名称声明_ 扩展 声明_ {
        名称?: 标识符_;
    }

    导出 接口 声明语句_ 扩展 名称声明_, 语句_ {
        名称?: 标识符_;
    }

    导出 接口 签名声明基类_ 扩展 名称声明_, JSDoc容器_ {
        种类: 签名声明_['种类'];
        名称?: 标识符_;
        参数?: 节点数组_<参数声明_>;
        类型?: 返回值声明属性组_;
        类型参数?:节点数组_<类型参数声明_>
        类型实参?:节点数组_<类型节点_>
    }

    导出 类型 签名声明_ =
        | 方法签名_
        | 函数类型节点_
        | 函数声明_
        | 方法声明_
        | 函数表达式_
        | 箭头函数_
        | 函数签名_
        | 创建函数签名_
        ;

    导出 接口 导入成员_ 扩展 名称声明_, JSDoc容器_ {
        种类: 语法_.导入成员_
        别名?: 标识符_
        模块名: 文本字面量_
    }

    导出 接口 导入声明_ 扩展 声明语句_, JSDoc容器_ {
        种类: 语法_.导入声明_
        导入组: 节点数组_<导入成员_>
    }

    导出 接口 导入从成员_ 扩展 名称声明_, JSDoc容器_ {
        种类: 语法_.导入从成员_
        名称: 标识符_
        别名?: 标识符_
    }

    导出 接口 导入从声明_ 扩展 声明语句_, JSDoc容器_ {
        种类: 语法_.导入从声明_
        导入组: 节点数组_<导入从成员_>
        模块名: 文本字面量_
    }

    导出 接口 变量声明_ 扩展 名称声明_, JSDoc容器_ {
        种类: 语法_.变量声明_;
        名称: 标识符_;
        类型?: 类型节点_;
    }

    导出 接口 参数声明_ 扩展 名称声明_, JSDoc容器_ {
        种类: 语法_.参数_;
        名称: 标识符_;
        类型?: 类型节点_;
    }

    导出 接口 接受者声明_ 扩展 声明_, JSDoc容器_ {
        种类: 语法_.接受者声明_
        类型: 类型节点_
    }

    导出 接口 属性声明_ 扩展 名称声明_, JSDoc容器_ {
        种类: 语法_.属性声明_;
        是匿名成员?: 真假
        名称?: 标识符_;
        类型: 类型节点_;
    }

    导出 类型 变量族声明_ =
        | 常量声明_
        | 常量列表元素_
        | 变量声明_
        | 参数声明_
        | 属性声明_
        ;

    导出 接口 函数族声明基类_ 扩展 签名声明基类_ {
        _函数族声明支持: 任意;
        主体?: 块_ | 表达式_;
    }

    
    导出 类型 普通函数族声明_ =
        | 函数声明_
        | 方法声明_
        | 函数表达式_
        | 箭头函数_
        ;

    导出 类型 函数族声明_ =
        | 函数声明_
        | 启动函数声明_
        | 初始函数声明_
        | 方法声明_
        | 函数表达式_
        | 箭头函数_
        ;
    
        导出 类型 普通数族声明_ =
        | 函数声明_
        | 方法声明_
        | 函数表达式_
        | 箭头函数_
        ;

    导出 接口 启动函数声明_ 扩展 声明语句_ {
        种类: 语法_.启动函数声明_;
        主体?: 函数主体_;
    }

    导出 接口 初始函数声明_ 扩展 声明语句_ {
        种类: 语法_.初始函数声明_;
        主体?: 函数主体_;
    }

    导出 接口 函数声明_ 扩展 函数族声明基类_, 声明语句_, JSDoc容器_ {
        种类: 语法_.函数声明_;
        名称?: 标识符_;
        主体?: 函数主体_;
    }

    导出 类型 函数签名族_ = 函数签名_ | 方法签名_ | 创建函数签名_

    导出 接口 函数签名_ 扩展 签名声明基类_, 声明语句_, JSDoc容器_{
        种类: 语法_.函数签名_
    }

    导出 接口 创建函数签名_ 扩展 签名声明基类_, 声明语句_, JSDoc容器_{
        种类: 语法_.创建函数签名_
        参数?: 节点数组_<参数声明_>;
        类型?: 返回值声明属性组_;
    }

    导出 接口 方法签名_ 扩展 签名声明基类_, 类型元素_, 声明语句_, JSDoc容器_ {
        种类: 语法_.方法签名_;
        父节点: 接口声明_;
        名称: 标识符_;
    }

    导出 接口 方法声明_ 扩展 函数族声明基类_, 声明语句_, JSDoc容器_ {
        种类: 语法_.方法声明_;
        接受者: 接受者声明_;
        名称: 标识符_;
        主体: 函数主体_;
    }

    导出 接口 类型节点_ 扩展 声明_, 节点_ {
        _类型节点支持: 任意;
    }

    导出 接口 指针类型节点_ 扩展 类型节点_ {
        种类: 语法_.指针类型_
        基础类型: 类型节点_
    }

    导出 接口 通信类型节点_ 扩展 类型节点_ {
        种类: 语法_.通信类型_
        元素类型: 类型节点_
    }

    导出 接口 只读通信节点_ 扩展 类型节点_ {
        种类: 语法_.只读通信_
        元素类型: 类型节点_
    }

    导出 接口 只写通信节点_ 扩展 类型节点_ {
        种类: 语法_.只写通信_
        元素类型: 类型节点_
    }

    导出 接口 函数类型节点_ 扩展 类型节点_, 签名声明基类_ {
        种类: 语法_.函数类型_;
    }

    导出 接口 类型引用节点_ 扩展 类型节点_ {
        种类: 语法_.类型引用_;
        类型名: 实体名称_;
        类型实参?: 节点数组_<类型节点_>
    }

    导出 接口 条件类型节点_ 扩展 类型节点_{
        种类: 语法_.条件类型_
        检查类型: 类型节点_
        条件类型: 类型节点_
        真类型: 类型节点_
        假类型: 类型节点_
    }

    导出 接口 三元类型节点_ 扩展 类型节点_{
        种类: 语法_.三元类型_
        条件类型: 类型节点_
        真类型: 类型节点_
        假类型: 类型节点_
    }

    导出 接口 列表类型节点_ 扩展 类型节点_ {
        种类: 语法_.列表类型_;
        元素类型: 类型节点_;
    }

    导出 接口 数组类型节点_ 扩展 类型节点_ {
        种类: 语法_.数组类型_;
        元素类型: 类型节点_;
        长度?: 表达式_;
    }

    导出 接口 变长参数类型_ 扩展 类型节点_ {
        种类: 语法_.变长参数类型_
        元素类型: 类型节点_
    }

    导出 接口 词典类型节点_ 扩展 类型节点_ {
        种类: 语法_.词典类型_
        键类型: 类型节点_
        值类型: 类型节点_
    }

    导出 接口 联合类型节点_ 扩展 类型节点_ {
        种类: 语法_.联合类型_;
        类型组: 节点数组_<类型节点_>;
    }

    导出 接口 交叉类型节点_ 扩展 类型节点_ {
        种类: 语法_.交叉类型_;
        类型组: 节点数组_<类型节点_>;
    }

    导出 接口 括号类型节点_ 扩展 类型节点_ {
        种类: 语法_.括号类型_;
        类型: 类型节点_;
    }

    导出 接口 字符字面量_ 扩展 字面量表达式_ {
        种类: 语法_.字符字面量_;
    }

    导出 接口 文本字面量_ 扩展 字面量表达式_ {
        种类: 语法_.文本字面量_;
        /* @internal */ 文本源码节点?: 标识符_ | 字面量族_ | 数字字面量_;
    }

    导出 类型 字面量族_ = 文本字面量_ | 字符字面量_ | 无替换模板字面量_;

    导出 接口 表达式_ 扩展 节点_ {
        _表达式支持: 任意;
    }

    导出 接口 展开元素_ 扩展 表达式_ {
        种类: 语法_.展开元素_;
        父节点: 调用表达式_;
        表达式: 表达式_
    }

    导出 接口 省略表达式_ 扩展 表达式_ {
        种类: 语法_.省略表达式_;
    }

    导出 接口 部分输出语句_ 扩展 左侧表达式_ {
        种类: 语法_.部分输出表达式_;
        表达式: 表达式_;
    }

    导出 接口 一元表达式_ 扩展 表达式_ {
        _一元表达式支持: 任意;
    }

    导出 类型 增量表达式_ = 更新表达式_;
    导出 接口 更新表达式_ 扩展 一元表达式_ {
        _更新表达式支持: 任意;
    }

    // see: https://tc39.github.io/ecma262/#prod-更新表达式_
    // see: https://tc39.github.io/ecma262/#prod-一元表达式_
    导出 类型 前缀一元运算符_
        = 语法_.且号_
        | 语法_.星号_
        | 语法_.加号_
        | 语法_.减号_
        | 语法_.波折号_
        | 语法_.叹号_
        ;

    导出 类型 前缀一元表达式种类 = 语法_.前缀一元表达式_ | 语法_.取值表达式_ | 语法_.取址表达式_;

    导出 接口 前缀一元表达式_ 扩展 更新表达式_ {
        种类: 前缀一元表达式种类;
        运算符: 前缀一元运算符_;
        算子: 一元表达式_;
    }

    导出 接口 取值表达式_ 扩展 前缀一元表达式_ {
        种类: 语法_.取值表达式_;
        运算符: 语法_.星号_;
        算子: 一元表达式_
    }

    导出 接口 取址表达式_ 扩展 前缀一元表达式_ {
        种类: 语法_.取址表达式_;
        运算符: 语法_.且号_
        算子: 一元表达式_
    }

    // see: https://tc39.github.io/ecma262/#prod-更新表达式_
    导出 类型 后缀一元运算符_
        = 语法_.双加号_
        | 语法_.双减号_
        | 语法_.减右尖号_
        ;

    导出 接口 后缀读信道表达式_ 扩展 更新表达式_, 一元表达式_ {
        种类: 语法_.后缀读信道表达式_;
        算子: 左侧表达式_;
        运算符: 语法_.减右尖号_;
    }

    导出 接口 后缀一元表达式_ 扩展 更新表达式_ {
        种类: 语法_.后缀一元表达式_;
        算子: 左侧表达式_;
        运算符: 后缀一元运算符_;
    }

    导出 接口 左侧表达式_ 扩展 更新表达式_ {
        _左处理表达式支持: 任意;
    }

    导出 接口 成员表达式_ 扩展 左侧表达式_ {
        _成员表达式支持: 任意;
    }

    导出 接口 基本表达式_ 扩展 成员表达式_ {
        _基本表达式支持: 任意;
    }

    导出 接口 字面量初始化表达式_ 扩展 基本表达式_ {
        类型?: 类型节点_;
        表达式: 基本表达式_;
    }

    导出 接口 无值表达式_ 扩展 一元表达式_ {
        种类: 语法_.无值表达式_;
        表达式: 一元表达式_;
    }

    // see: https://tc39.github.io/ecma262/#prod-乘法运算符_
    导出 类型 乘法运算符_
        = 语法_.星号_
        | 语法_.斜杠号_
        | 语法_.百分号_
        ;

    // see: https://tc39.github.io/ecma262/#prod-MultiplicativeExpression
    导出 类型 乘法运算符或更高_
        = 乘法运算符_
        ;

    // see: https://tc39.github.io/ecma262/#prod-AdditiveExpression
    导出 类型 加法运算符_
        = 语法_.加号_
        | 语法_.减号_
        ;

    // see: https://tc39.github.io/ecma262/#prod-AdditiveExpression
    导出 类型 加法运算符或更高_
        = 乘法运算符或更高_
        | 加法运算符_
        ;

    // see: https://tc39.github.io/ecma262/#prod-ShiftExpression
    导出 类型 位移运算符_
        = 语法_.双左尖号_
        | 语法_.双右尖号_
        ;

    // see: https://tc39.github.io/ecma262/#prod-ShiftExpression
    导出 类型 位移运算符或更高_
        = 加法运算符或更高_
        | 位移运算符_
        ;

    // see: https://tc39.github.io/ecma262/#prod-RelationalExpression
    导出 类型 关系运算符_
        = 语法_.左尖号_
        | 语法_.左尖等号_
        | 语法_.右尖号_
        | 语法_.右尖等号_
        | 语法_.位于_
        ;

    // see: https://tc39.github.io/ecma262/#prod-RelationalExpression
    导出 类型 关系运算符或更高_
        = 位移运算符或更高_
        | 关系运算符_
        ;

    // see: https://tc39.github.io/ecma262/#prod-EqualityExpression
    导出 类型 相等运算符_
        = 语法_.双等号_
        | 语法_.叹号等号_
        ;

    // see: https://tc39.github.io/ecma262/#prod-EqualityExpression
    导出 类型 相等运算符或更高_
        = 关系运算符或更高_
        | 相等运算符_
        ;

    // see: https://tc39.github.io/ecma262/#prod-BitwiseANDExpression
    // see: https://tc39.github.io/ecma262/#prod-BitwiseXORExpression
    // see: https://tc39.github.io/ecma262/#prod-BitwiseORExpression
    导出 类型 位运算符_
        = 语法_.且号_
        | 语法_.或号_
        | 语法_.异或号_
        ;

    // see: https://tc39.github.io/ecma262/#prod-BitwiseANDExpression
    // see: https://tc39.github.io/ecma262/#prod-BitwiseXORExpression
    // see: https://tc39.github.io/ecma262/#prod-BitwiseORExpression
    导出 类型 位运算符或更高_
        = 相等运算符或更高_
        | 位运算符_
        ;

    // see: https://tc39.github.io/ecma262/#prod-LogicalANDExpression
    // see: https://tc39.github.io/ecma262/#prod-LogicalORExpression
    导出 类型 逻辑运算符_
        = 语法_.双且号_
        | 语法_.双或号_
        ;

    // see: https://tc39.github.io/ecma262/#prod-LogicalANDExpression
    // see: https://tc39.github.io/ecma262/#prod-LogicalORExpression
    导出 类型 逻辑运算符或更高_
        = 位运算符或更高_
        | 逻辑运算符_
        ;

    // see: https://tc39.github.io/ecma262/#prod-赋值运算符_
    导出 类型 复合赋值运算符_
        = 语法_.加等号_
        | 语法_.减等号_
        | 语法_.星等号_
        | 语法_.斜杠等号_
        | 语法_.百分等号_
        | 语法_.且等号_
        | 语法_.或等号_
        | 语法_.异或等号_
        | 语法_.双左尖等号_
        | 语法_.双右尖等号_
        ;

    // see: https://tc39.github.io/ecma262/#prod-赋值表达式_
    导出 类型 赋值运算符_
        = 语法_.等号_
        | 语法_.冒等号_
        | 语法_.减右尖号_
        | 语法_.左尖减号_
        | 复合赋值运算符_
        ;

    // see: https://tc39.github.io/ecma262/#prod-赋值表达式_
    导出 类型 赋值运算符或更高_
        = 逻辑运算符或更高_
        | 赋值运算符_
        ;

    // see: https://tc39.github.io/ecma262/#prod-表达式_
    导出 类型 二元运算符_
        = 赋值运算符或更高_
        | 语法_.逗号_
        ;

    导出 类型 二元运算符令牌_ = 令牌_<二元运算符_>;

    导出 接口 二元表达式_ 扩展 表达式_, 声明_ {
        种类: 语法_.二元表达式_;
        左侧: 表达式_;
        运算符令牌: 二元运算符令牌_;
        右侧: 表达式_;
    }

    导出 类型 赋值运算符令牌_ = 令牌_<赋值运算符_>;

    导出 接口 赋值表达式_<T运算符_ 扩展 赋值运算符令牌_> 扩展 二元表达式_ {
        左侧: 左侧表达式_;
        运算符令牌: T运算符_;
    }

    导出 类型 绑定或赋值元素_
        = 变量声明_
        | 参数声明_
        | 省略表达式_ // Elision
        | 数组字面量表达式_ // 数组赋值模式_
        | 结构字面量表达式_ // 对象赋值模式_
        | 赋值表达式_<等号_> // AssignmentElement        
        | 赋值表达式_<冒等号_> // AssignmentElement
        | 标识符_ // DestructuringAssignmentTarget
        | 属性访问表达式_ // DestructuringAssignmentTarget
        | 元素访问表达式_ // DestructuringAssignmentTarget
        ;

    导出 类型 绑定或赋值元素剩余指示器_
        = 三点号_ // from 绑定元素_
        ;

    导出 类型 绑定或赋值元素目标_ = 绑定或赋值模式_ | 标识符_ | 属性访问表达式_ | 元素访问表达式_ | 省略表达式_;

    导出 类型 结构绑定或赋值模式_ =
        | 结构字面量表达式_ // 对象赋值模式_
        ;

    导出 类型 数组绑定或赋值模式_ =
        | 数组字面量表达式_ // 数组赋值模式_
        ;

    导出 类型 赋值模式_ = 结构字面量表达式_ | 数组字面量表达式_;

    导出 类型 绑定或赋值模式_ = 结构绑定或赋值模式_ | 数组绑定或赋值模式_;

    导出 接口 条件表达式_ 扩展 表达式_ {
        种类: 语法_.条件表达式_;
        条件: 表达式_;
        问号: 问号_;
        当为真: 表达式_;
        冒号: 冒号_;
        当为假: 表达式_;
    }

    导出 类型 函数主体_ = 块_;
    导出 类型 简洁主体_ = 函数主体_ | 表达式_;

    导出 接口 函数表达式_ 扩展 基本表达式_, 函数族声明基类_, JSDoc容器_, 声明语句_ {
        种类: 语法_.函数表达式_;
        名称?: 标识符_;
        主体?: 函数主体_;  // Required, whereas the member inherited from 函数声明_ is optional
    }

    导出 接口 箭头函数_ 扩展 左侧表达式_, 函数族声明基类_, JSDoc容器_, 声明语句_ {
        种类: 语法_.箭头函数_;
        等右尖号: 等右尖号_ | 等右尖冒号_
        主体?: 简洁主体_;
        名称: 不及;
    }

    导出 接口 字面量族节点_ 扩展 节点_ {
        文本: 文字;
        是未终止的?: 真假;
        有扩展万码转义?: 真假;
    }

    导出 接口 字面量表达式_ 扩展 字面量族节点_, 基本表达式_ {
        _左侧表达式支持: 任意;
    }

    导出 接口 正则表达式字面量_ 扩展 字面量表达式_ {
        种类: 语法_.正则表达式字面量_;
    }

    导出 接口 无替换模板字面量_ 扩展 字面量表达式_ {
        种类: 语法_.无替换模板字面量_;
    }

    /* @internal */
    导出 常量 枚举 令牌标志_ {
        无_ = 0,
        前导换行_ = 1 << 0,
        前导JSDoc注释_ = 1 << 1,
        未终止的_ = 1 << 2,
        扩展万码转义_ = 1 << 3,
        科学计数_ = 1 << 4,        // e.g. `10e2`
        八进制_ = 1 << 5,             // e.g. `0777`
        十六进制说明符_ = 1 << 6,      // e.g. `0x00000000`
        二进制说明符_ = 1 << 7,   // e.g. `0b0110010000000000`
        八进制说明符_ = 1 << 8,    // e.g. `0o777`
        包含分隔符_ = 1 << 9, // e.g. `0b1100_0101`        
        预处理开始_ = 1 << 10,
        预处理结束_ = 1 << 11,
        虚部_ = 1 << 12,        
        是私有的_ = 1 << 27,
        是空标识符_ = 1 << 28,
        修饰符标志_ = 是私有的_ | 是空标识符_,
        二进制或八进制说明符_ = 二进制说明符_ | 八进制说明符_,
        数字字面量标志_ = 科学计数_ | 八进制_ | 十六进制说明符_ | 二进制说明符_ | 八进制说明符_ | 包含分隔符_ | 虚部_
    }

    导出 接口 数字字面量_ 扩展 字面量表达式_ {
        种类: 语法_.数字字面量_;
        /* @internal */
        数字字面量标志: 令牌标志_;
        是虚部?: 真假
    }

    导出 接口 模板头_ 扩展 字面量族节点_ {
        种类: 语法_.模板头_;
        父节点: 模板表达式_;
    }

    导出 接口 模板中_ 扩展 字面量族节点_ {
        种类: 语法_.模板中_;
        父节点: 模板跨度_;
    }

    导出 接口 模板尾_ 扩展 字面量族节点_ {
        种类: 语法_.模板尾_;
        父节点: 模板跨度_;
    }

    导出 类型 模板字面量_ = 模板表达式_ | 无替换模板字面量_;

    导出 接口 模板表达式_ 扩展 基本表达式_ {
        种类: 语法_.模板表达式_;
        头部: 模板头_;
        模板跨度组: 节点数组_<模板跨度_>;
    }

    导出 接口 模板跨度_ 扩展 节点_ {
        种类: 语法_.模板跨度_;
        父节点: 模板表达式_;
        表达式: 表达式_;
        字面量: 模板中_ | 模板尾_;
    }

    导出 接口 括号表达式_ 扩展 基本表达式_, JSDoc容器_ {
        种类: 语法_.括号表达式_;
        表达式: 表达式_;
    }

    导出 接口 数组字面量表达式_ 扩展 基本表达式_ {
        种类: 语法_.数组字面量表达式_;
        元素类型: 类型节点_;
        元素: 节点数组_<表达式_ | 数组或列表字面量表达式_>;
        /* @internal */
        多行?: 真假;
    }

    导出 接口 数组或列表字面量表达式_ 扩展 基本表达式_ {
        种类: 语法_.数组或列表字面量表达式_,
        元素: 节点数组_<表达式_>;
        /* @internal */
        多行?: 真假;
    }

    导出 接口 列表字面量表达式_ 扩展 基本表达式_ {
        种类: 语法_.列表字面量表达式_;
        元素类型: 类型节点_;
        元素: 节点数组_<表达式_ | 数组或列表字面量表达式_>;
        /* @internal */
        多行?: 真假;
    }

    导出 接口 词典键值表达式_ 扩展 表达式_ {
        种类: 语法_.词典键值表达式_
        键类型: 类型节点_;
        值类型: 类型节点_;
        键表达式: 表达式_
        值表达式: 表达式_
    }

    导出 接口 词典字面量表达式_ 扩展 基本表达式_ {
        种类: 语法_.词典字面量表达式_;
        元素类型: 词典类型节点_;
        元素: 节点数组_<词典键值表达式_>;
        /* @internal */
        多行?: 真假;
    }

    导出 接口 写入通信表达式_ 扩展 表达式_, 语句_ {
        种类: 语法_.写入通信表达式_;
        左侧: 表达式_;
        右侧: 表达式_;
    }

    导出 接口 表达式包括类型参数_ 扩展 基本表达式_, 类型节点_ {
        种类: 语法_.表达式包括类型参数_
        表达式: 表达式_
        类型实参: 节点数组_<类型节点_>
    }

    导出 接口 结构字面量表达式_ 扩展 声明_, 基本表达式_ {
        种类: 语法_.结构字面量表达式_;
        结构体类型名: 类型引用节点_;
        属性组: 节点数组_<结构字面量成员表达式_>
        /* @internal */
        多行?: 真假;
    }

    导出 接口 结构字面量成员表达式_ 扩展 名称声明_, 表达式_ {
        种类: 语法_.结构字面量成员表达式_;
        名称: 标识符_
        初始化: 表达式_;
    }

    导出 类型 实体名表达式_ = 标识符_ | 属性访问实体名称表达式_;
    导出 类型 实体名或实体名表达式_ = 实体名称_ | 实体名表达式_;

    导出 接口 属性访问表达式_ 扩展 成员表达式_, 名称声明_ {
        种类: 语法_.属性访问表达式_;
        表达式: 左侧表达式_;
        问号?: 语法_.问号_
        名称: 标识符_;
    }

    导出 接口 属性访问实体名称表达式_ 扩展 属性访问表达式_ {
        _属性访问表达式族限定名支持?: 任意;
        表达式: 实体名表达式_;
    }

    导出 接口 元素访问表达式_ 扩展 成员表达式_ {
        种类: 语法_.元素访问表达式_;
        表达式: 左侧表达式_;
        问号?: 语法_.问号_
        参数表达式: 表达式_;
    }

    导出 接口 调用表达式_ 扩展 左侧表达式_, 声明_ {
        种类: 语法_.调用表达式_;
        表达式: 左侧表达式_;
        实参组: 节点数组_<表达式_>;
        类型实参?: 节点数组_<类型节点_>
    }

    导出 接口 新建表达式_ 扩展 基本表达式_, 声明_ {
        种类: 语法_.新建表达式_;
        类型参数: 类型节点_;
        类型实参?: 节点数组_<类型节点_>
    }

    导出 接口 创建表达式_ 扩展 基本表达式_, 声明_ {
        种类: 语法_.创建表达式_;        
        类型实参?: 节点数组_<类型节点_>
        实参1?: 表达式_;
        实参2?: 表达式_;
    }

    导出 接口 标记模板表达式_ 扩展 成员表达式_ {
        种类: 语法_.标记模板表达式_;
        标签: 左侧表达式_;
        模板: 模板字面量_;
    }

    导出 类型 调用族表达式_ = 调用表达式_ | 创建表达式_ | 标记模板表达式_;

    // <类型名称>表达式 || 表达式.(类型名称)
    导出 接口 类型转换表达式_ 扩展 基本表达式_, 一元表达式_ {
        种类: 语法_.类型转换表达式_;
        类型: 类型节点_;
        表达式: 表达式_;
    }

    // ok, err := 表达式.<类型名称> // 表达式的基础类型必须是 通用型 或 联合类型
    导出 接口 类型断言表达式_ 扩展 基本表达式_ {
        种类: 语法_.类型断言表达式_;
        类型: 类型节点_;
        表达式: 左侧表达式_;
    }

   /**
    * 表达式的基础类型必须是 通用型 或 联合类型
    * 联合类型 是 通用类型的 缩小版本
    * 通用型 是空接口类型 所有类型都实现了 通用型 接口
    * 
    * 联合类型 是 几个接口类型的组合 例如:  接口类型1 | 接口类型2 | 接口类型3
    * 联合类型的成员只能是接口类型
    * 
    * 参数尽量约束 接口类型, 不要访问类型的属性, 属性应通过方法来访问
    * 
    * 假如(表达式.<类型>){
    *     若是 XXX:
    *         ...     // 默认具有 跳出
    *     若是 xxx:
    *         ...     // 默认具有 跳出
    * }
    */
    导出 接口 类型查询表达式_ 扩展 基本表达式_ {
        种类: 语法_.类型查询表达式_;
        类型: 语法_.类型_;
        表达式: 左侧表达式_;
    }

    导出 类型 断言表达式_ = 类型断言表达式_ | 类型转换表达式_ | 类型查询表达式_;

    导出 接口 语句_ 扩展 节点_ {
        _语句支持: 任意;
    }

    导出 接口 不输出语句_ 扩展 语句_ {
        种类: 语法_.不输出语句_;
    }

    /**
     * Marks the 尾位 of transformed declaration to properly emit 导出表.
     */
    /* @internal */
    导出 接口 声明结束标志_ 扩展 语句_ {
        种类: 语法_.声明结束标志_;
    }

    
    导出 常量 枚举 外部表达式种类_ {
        Parentheses = 1 << 0,
        Assertions = 1 << 1,
        PartiallyEmittedExpressions = 1 << 2,

        All = Parentheses | Assertions | PartiallyEmittedExpressions
    }

    导出 类型 OuterExpression = 括号表达式_ | 类型断言表达式_;
    /**
     * Marks the beginning of a merged transformed declaration.
     */
    /* @internal */
    导出 接口 合并声明标记_ 扩展 语句_ {
        种类: 语法_.合并声明标记_;
    }

    导出 接口 空语句_ 扩展 语句_ {
        种类: 语法_.空语句_;
    }

    导出 接口 调试语句_ 扩展 语句_ {
        种类: 语法_.调试语句_;
    }

    导出 接口 失踪声明_ 扩展 声明语句_, 名称声明_, 类型元素_ {
        种类: 语法_.失踪声明_;
        名称?: 标识符_;
    }

    导出 类型 块族_ = 源文件_ | 块_ | 若是或默认子句_;

    导出 接口 块_ 扩展 语句_ {
        种类: 语法_.块_;
        语句组: 节点数组_<语句_>;
        /*@internal*/ 多行?: 真假;
    }

    导出 接口 常量声明_ 扩展 名称声明_ , JSDoc容器_{
        种类: 语法_.常量声明_;
        名称: 标识符_;
        初始化?:表达式_;
    }

    导出 接口 常量列表元素_ 扩展 名称声明_ , JSDoc容器_{
        种类: 语法_.常量列表元素_;
        名称: 标识符_;        
        初始化?: 表达式_;        
    }

    导出 接口 常量列表语句_ 扩展 语句_, JSDoc容器_ {
        种类: 语法_.常量列表语句_;
        声明组: 节点数组_<常量列表元素_>
    }

    导出 接口 常量语句_ 扩展 语句_, JSDoc容器_ {
        种类: 语法_.常量语句_;
        声明组: 节点数组_<常量声明_>
        初始化组: 节点数组_<表达式_>
    }

    导出 接口 变量语句_ 扩展 语句_, JSDoc容器_ {
        种类: 语法_.变量语句_;
        声明组: 节点数组_<变量声明_>
        初始化组?: 节点数组_<表达式_>
    }

    导出 接口 简洁变量语句_ 扩展 语句_, JSDoc容器_ {
        种类: 语法_.简洁变量语句_;
        声明组: 节点数组_<变量声明_>
        初始化组?: 节点数组_<表达式_>
    }

    导出 接口 表达式语句_ 扩展 语句_, JSDoc容器_ {
        种类: 语法_.表达式语句_;
        表达式: 表达式_;
    }

    /* @internal */
    导出 接口 序言指令_ 扩展 表达式语句_ {
        表达式: 文本字面量_;
    }

    导出 接口 如果语句_ 扩展 语句_ {
        种类: 语法_.如果语句_;
        表达式: 表达式_;
        然后语句: 语句_;
        另如语句?: 另如语句_;
        否则语句?: 语句_;
    }
    
    导出 接口 另如语句_ 扩展 语句_ {
        种类: 语法_.另如语句_;
        表达式: 表达式_;
        然后语句: 语句_;
        另如语句?: 另如语句_;
        否则语句?: 语句_;
    }

    导出 接口 执行语句_ 扩展 语句_ {
        种类: 语法_.执行语句_
        表达式: 表达式_
    }

    导出 接口 善后语句_ 扩展 语句_ {
        种类: 语法_.善后语句_
        表达式: 表达式_
    }

    导出 接口 删除语句_ 扩展 语句_ {
        种类: 语法_.删除语句_;
        表达式: 元素访问表达式_;
    }

    导出 接口 迭代语句_ 扩展 语句_ {
        语句: 语句_;
    }

    导出 类型 循环初始化_ = 变量声明_ | 表达式_;

    导出 接口 循环语句_ 扩展 语句_ {
        种类: 语法_.循环语句_;
        父节点: 块_;
        初始化?: 简洁变量语句_;
        条件?: 表达式_;
        增量器?: 节点数组_<表达式_>;
        迭代体: 块_;
    }

    导出 接口 循环属于语句_ 扩展 语句_ {
        种类: 语法_.循环属于语句_;
        声明组: 节点数组_<变量声明_>
        表达式: 表达式_
        迭代体: 块_;
    }

    导出 接口 跳出语句_ 扩展 语句_ {
        种类: 语法_.跳出语句_;
        标签?: 标识符_;
    }

    导出 接口 贯穿语句_ 扩展 语句_ {
        种类: 语法_.贯穿语句_;
    }

    导出 接口 继续语句_ 扩展 语句_ {
        种类: 语法_.继续语句_;
        标签?: 标识符_;
    }

    导出 类型 跳出或继续语句_ = 跳出语句_ | 继续语句_;

    导出 接口 返回语句_ 扩展 语句_ {
        种类: 语法_.返回语句_;
        表达式?: 节点数组_<表达式_>;
    }

    导出 接口 选择语句_ 扩展 语句_ {
        种类: 语法_.选择语句_;
        表达式: 表达式_;
        若是块: 若是块_;
        可能是详尽的?: 真假;
    }

    导出 接口 假如语句_ 扩展 语句_ {
        种类: 语法_.假如语句_;
        表达式: 表达式_;
        若是块: 若是块_;
        可能是详尽的?: 真假;
    }

    导出 接口 若是块_ 扩展 节点_ {
        种类: 语法_.若是块_;
        父节点: 假如语句_;
        子句组: 节点数组_<若是或默认子句_>;
    }

    导出 接口 若是子句_ 扩展 节点_ {
        种类: 语法_.若是子句_;
        父节点: 若是块_;
        表达式: 表达式_;
        语句组: 节点数组_<语句_>;
    }

    导出 接口 默认子句_ 扩展 节点_ {
        种类: 语法_.默认子句_;
        父节点: 若是块_;
        语句组: 节点数组_<语句_>;
    }

    导出 类型 若是或默认子句_ = 若是子句_ | 默认子句_;

    导出 接口 标签语句_ 扩展 语句_, JSDoc容器_ {
        种类: 语法_.标签语句_;
        标签: 标识符_;
        语句: 语句_;
    }

    导出 类型 声明包括类型参数_ =  签名声明_ | 结构声明_| 接口声明_ | 类型别名声明_ | 类型声明_ 

    导出 接口 类型元素_ 扩展 名称声明_ {
        _类型元素支持: 任意;
        名称?: 标识符_;        
    }

    导出 接口 结构声明属性组_ 扩展 声明_, JSDoc容器_ {
        种类: 语法_.结构声明属性组_
        具有匿名成员?: 真假
        声明组: 节点数组_<属性声明_>
    }

    导出 接口 返回值声明属性组_ 扩展 类型节点_, 声明_, JSDoc容器_ {
        种类: 语法_.返回值声明属性组_
        具有匿名成员?: 真假
        声明组: 节点数组_<属性声明_ | 类型节点_>
    }

    导出 接口 结构声明_ 扩展 声明语句_, JSDoc容器_ {
        种类: 语法_.结构声明_;
        名称: 标识符_;
        成员: 节点数组_<结构声明属性组_>;
        类型参数?:节点数组_<类型参数声明_>
    }

    导出 接口 枚举声明_ 扩展 声明语句_ , JSDoc容器_{
        种类: 语法_.枚举声明_
        名称: 标识符_
        成员: 节点数组_<枚举成员声明_>
    }

    导出 接口 枚举成员声明_ 扩展 名称声明_, JSDoc容器_{
        种类: 语法_.枚举成员声明_
        名称: 标识符_
        初始化?: 表达式_
    }

    导出 接口 接口声明_ 扩展 声明语句_, JSDoc容器_ {
        种类: 语法_.接口声明_;
        名称: 标识符_;        
        类型参数?:节点数组_<类型参数声明_>
        成员: 节点数组_<方法签名_ | 类型引用节点_>;
    }

    导出 接口 类型别名声明_ 扩展 声明语句_, JSDoc容器_ {
        种类: 语法_.类型别名声明_;
        名称: 标识符_;
        类型: 类型节点_;
        类型参数?:节点数组_<类型参数声明_>
    }

    导出 接口 类型声明_ 扩展 声明语句_, JSDoc容器_ {
        种类: 语法_.类型声明_;
        名称: 标识符_;
        类型: 类型节点_;
        类型参数?:节点数组_<类型参数声明_>
    }

    导出 接口 类型参数声明_ 扩展 名称声明_, 类型节点_ {
        种类: 语法_.类型参数声明_
        父节点: 声明包括类型参数_
        默认: 类型节点_
        约束: 类型节点_
        可选?: 真假
        // For error recovery purposes.
        表达式?: 表达式_;
    }

    导出 接口 程序声明_ 扩展 声明语句_, JSDoc容器_ {
        种类: 语法_.程序声明_;
        是启动声明?: 真假
        名称: 标识符_
        语句组: 节点数组_<顶级语句_>;
    }

    导出 类型 顶级语句_ =
        | 不输出语句_
        | 变量语句_
        | 常量语句_
        | 常量列表语句_
        | 方法声明_
        | 函数声明_
        | 函数签名_
        | 结构声明_
        | 接口声明_
        | 枚举声明_
        | 类型声明_
        | 类型别名声明_
        | 启动函数声明_
        | 初始函数声明_
        | 失踪语句_

    导出 类型 失踪语句_ = 语句_

    导出 类型 模块引用_ = 实体名称_;

    导出 接口 文件引用_ 扩展 文本范围_ {
        文件名: 文字;
    }

    导出 类型 注释种类_ = 语法_.单行注释杂项_ | 语法_.多行注释杂项_;

    导出 接口 注释范围_ 扩展 文本范围_ {
        有尾随新行?: 真假;
        种类: 注释种类_;
    }

    导出 接口 合成注释_ 扩展 注释范围_ {
        文本: 文字;
        首位: -1;
        尾位: -1;
    }

    导出 接口 JSDoc_ 扩展 节点_ {
        种类: 语法_.JsDoc注释_;
        父节点: 有JSDoc_;
        标签组: 节点数组_<JSDoc标签_> | 未定;
        注释: 文字 | 未定;
    }

    导出 接口 JSDoc标签_ 扩展 节点_ {
        父节点: JSDoc_;
        艾特: 艾特号_;
        标签名: 标识符_;
        注释: 文字 | 未定;
    }

    导出 接口 JSDoc未知标签_ 扩展 JSDoc标签_ {
        种类: 语法_.JSDoc标签_;
    }

    导出 常量 枚举 流程标志_ {
        无法到达_  = 1 << 0,  // Unreachable code
        开始_      = 1 << 1,  // Start of flow graph
        分支标签_  = 1 << 2,  // Non-looping junction
        循环标签_  = 1 << 3,  // Looping junction
        赋值_      = 1 << 4,  // Assignment
        真条件_    = 1 << 5,  // Condition known to be true
        假条件_    = 1 << 6,  // Condition known to be false
        假如子句_  = 1 << 7,  // Switch 语句 clause
        数组变异_  = 1 << 8,  // Potential 数组 mutation
        引用的_    = 1 << 9,  // Referenced as 前个 once
        共享的_    = 1 << 10, // Referenced as 前个 more than once
        最终之前_  = 1 << 11, // Injected edge that links pre-finally 标签 and pre-try flow
        最终之后_  = 1 << 12, // Injected edge that links post-finally flow with the rest of the graph
        标签_      = 分支标签_ | 循环标签_,
        条件_      = 真条件_ | 假条件_
    }

    导出 接口 流程锁_ {
        锁定的?: 真假;
    }

    导出 接口 最后之后流节点_ 扩展 流程节点基类_, 流程锁_ {
        前个: 流程节点_;
    }

    导出 接口 最后之前流节点_ 扩展 流程节点基类_ {
        前个: 流程节点_;
        锁: 流程锁_;
    }

    导出 类型 流程节点_ = | 最后之后流节点_ | 最后之前流节点_ | 流程开始_ | 流程标签_ | 流程赋值_ | 流程条件_ | 流程假如子句_ | 流程数组变异_;

    导出 接口 流程节点基类_ {
        标志: 流程标志_;
        id?: 数字;     // 节点_ id used by flow 类型 cache in checker
    }

    // 流程开始_ represents the 开始 of a control flow. For a function 表达式 or arrow
    // function, the container property references the function (which in turn has a 流程节点
    // property for the containing control flow).
    导出 接口 流程开始_ 扩展 流程节点基类_ {
        容器?: 函数表达式_ | 箭头函数_ | 方法声明_;
    }

    // 流程标签_ represents a junction with multiple possible preceding control flows.
    导出 接口 流程标签_ 扩展 流程节点基类_ {
        前面的组?: 流程节点_[];
    }

    // 流程赋值_ represents a n that assigns a value to a narrowable reference,
    // i.e. an 标识符 or a dotted 名称 that starts with an 标识符 or 'this'.
    导出 接口 流程赋值_ 扩展 流程节点基类_ {
        n: 表达式_ | 变量声明_;
        前个: 流程节点_;
    }

    // 流程条件_ represents a 条件 that is known to be true or false at the
    // n's location in the control flow.
    导出 接口 流程条件_ 扩展 流程节点基类_ {
        表达式: 表达式_;
        前个: 流程节点_;
    }

    导出 接口 流程假如子句_ 扩展 流程节点基类_ {
        假如语句_: 假如语句_;
        子句开始: 数字;     // Start index of case/默认 clause range
        子句结束: 数字;     // End index of case/默认 clause range
        前个: 流程节点_;
    }

    // 流程数组变异_ represents a n potentially mutates an 数组, i.e. an
    // operation of the form 'x.push(value)', 'x.unshift(value)' or 'x[nn] = value'.
    导出 接口 流程数组变异_ 扩展 流程节点基类_ {
        n: 调用表达式_ | 二元表达式_;
        前个: 流程节点_;
    }

    导出 类型 流类型_ = 类型_ | 不完整类型_;

    // Incomplete 类型组 occur during control flow analysis of loops. An 不完整类型_
    // is distinguished from a regular 类型 by a 标志 value of zero. Incomplete 类型
    // objects are internal to the getFlowTypeOfRefecence function and never escape it.
    导出 接口 不完整类型_ {
        标志: 类型标志_;  // No 标志 set
        类型: 类型_;        // The 类型 marked incomplete
    }

    /* @internal */
    /**
     * Subset of 属性组 from 源文件_ that are used in multiple utility functions
     */
    导出 接口 源文件族_ {
        只读 文本: 文字;
        行词典?: 只读数组_<数字>;
    }

    /* @internal */
    导出 接口 重定向信息_ {
        /** Source 文件 this redirects to. */
        只读 重定向目标_: 源文件_;
        /**
         * Source 文件 for the duplicate package. This will not be used by the Program,
         * but we need to keep this around so we can watch for changes in underlying.
         */
        只读 未定向: 源文件_;
    }

    // Source files are 声明组 when they are external modules.
    导出 接口 源文件_ 扩展 声明_ {
        种类: 语法_.源文件_;
        语句组: 节点数组_<语句_>;
        程序集: 符号_
        文件结尾令牌: 令牌_<语法_.文件结尾令牌_>;
        文件名: 文字;
        文件导入位置: 模块导入位置种类_;
        /* @internal */ 路径: 路径_;
        文本: 文字;

        /**
         * If two source files are for the same version of the same package, one will redirect to the other.
         * (See `createRedirectSourceFile` in program.ts.)
         * The redirect will have this set. The other will not have anything set, but see Program#sourceFileIsRedirectedTo.
         */
        /* @internal */ 重定向信息?: 重定向信息_ | 未定;
        模块名称: 文字;
        语言版本: 语言版本_;
        是声明文件: 真假;
        是默认支持库?: 真假;

        // this map is used by transpiler to supply alternative names for dependencies (i.e. in case of bundling)
        /* @internal */
        重命名依赖?: 词典_<文字>;

        脚本目标: 脚本目标_;
        /* @internal */ 脚本种类: 脚本种类_;

        /* @internal */ 标识符组: 词典_<文字>; // Map from a string to an interned string
        /* @internal */ 节点数量: 数字;
        /* @internal */ 标识符数量: 数字;
        /* @internal */ 符号数量: 数字;

        // File-level diagnostics reported by the parser (includes diagnostics about /// references
        // as well as code diagnostics).
        /* @internal */ 解析诊断信息: 诊断_[];

        // File-level diagnostics reported by the binder.
        /* @internal */ 绑定诊断信息组: 诊断_[];

        // File-level JSDoc diagnostics reported by the JSDoc parser
        /* @internal */ jsDoc诊断信息?: 诊断_[];

        // Stores additional 文件-level diagnostics reported by the program
        /* @internal */ 附加语法诊断信息?: 只读数组_<诊断_>;

        // Stores a line map for the 文件.
        // This field should never be used directly to obtain line map, use getLineMap function instead.
        /* @internal */ 行词典: 只读数组_<数字>;

        /* @internal */ 解析的模块: 词典_<解析的模块名称_ | 未定>;
        /* @internal */ 导入组: 只读数组_<文本字面量_>;
        /* @internal */ 版本: 文字;
    }

    导出 常量 枚举 模块导入位置种类_ {
        无_ = 0,
        外部支持库_ = 1,
        全局支持库_ = 2,
    }

    导出 接口 解析的模块名称_ {
        模块名称? : 标识符_
        解析的模块目录路径: 文字
        全部源码文件名?: 文字[]
        是启动模块?: 真假
        是外部支持库导入?: 模块导入位置种类_
    }

    导出 接口 模块_ 扩展 节点_ {
        种类: 语法_.模块_;
        模块名称: 标识符_
        解析的模块目录路径: 文字;
        是启动模块: 真假;
        是外部支持库导入: 模块导入位置种类_;
        源文件组: 只读数组_<源文件_>;
    }

    导出 接口 源文件集_ 扩展 节点_ {
        种类: 语法_.源文件集_;
        源文件组: 只读数组_<源文件_>;
    }

    导出 接口 脚本引用主机_ {
        获取编译选项(): 编译选项_;
        获取源文件(文件名: 文字): 源文件_;
        获取源文件从路径(路径: 路径_): 源文件_ | 未定;
        获取当前目录(): 文字;
    }

    导出 接口 解析配置主机_ {
        使用区分大小写文件名: 真假;

        读目录(根目录: 文字, 扩展组: 只读数组_<文字>, 深度?: 数字): 文字[];

        /**
         * Gets a value indicating whether the specified 路径 exists and is a 文件.
         * @param 路径 The 路径 to test.
         */
        文件存在(路径: 文字): 真假;

        读文件(路径: 文字): 文字 | 未定;
    }

    导出 类型 写文件回调_ = (
        文件名: 文字,
        数据: 文字,
        写字节序标记: 真假,
        正在错误: ((消息: 文字) => 无值) | 未定,
        源文件组: 只读数组_<源文件_>,
    ) => 无值;

    导出 类别 操作取消异常_ { }

    导出 接口 取消令牌_ {
        是已取消请求(): 真假;

        /** @throws OperationCanceledException if isCancellationRequested is true */
        如果请求取消则抛出(): 无值;
    }

    导出 接口 程序_ 扩展 脚本引用主机_ {

        /**
         * Get a 列表 of root 文件 names that were passed to a 'createProgram'
         */
        获取根文件名称(): 只读数组_<文字>;

        /**
         * Get a 列表 of files in the program
         */
        获取源文件组(): 只读数组_<源文件_>;

        /**
         * Get a 列表 of 文件 names that were passed to 'createProgram' or referenced in a
         * program source 文件 but could not be located.
         */
        /* @internal */
        获取失踪文件路径(): 只读数组_<路径_>;

        /**
         * Emits the JavaScript and declaration files.  If targetSourceFile is not specified, then
         * the JavaScript and declaration files will be produced for all the files in this program.
         * If targetSourceFile is specified, then only the JavaScript and declaration for that
         * specific 文件 will be generated.
         *
         * If writeFile is not specified then the writeFile callback from the compiler host will be
         * used for writing the JavaScript and declaration files.  Otherwise, the writeFile 参数
         * will be invoked when writing the JavaScript and declaration files.
         */
        输出(目标源文件?: 源文件_, 写文件?: 写文件回调_, 取消令牌?: 取消令牌_, 输出仅声明文件_?: 真假, 自定义转换器?: 自定义转换器_): 输出结果_;

        获取选项诊断信息(取消令牌?: 取消令牌_): 只读数组_<诊断_>;
        获取全局诊断信息(取消令牌?: 取消令牌_): 只读数组_<诊断_>;
        获取语法诊断信息(源文件?: 源文件_, 取消令牌?: 取消令牌_): 只读数组_<诊断_>;
        获取语义诊断信息(源文件?: 源文件_, 取消令牌?: 取消令牌_): 只读数组_<诊断_>;
        获取声明诊断信息(源文件?: 源文件_, 取消令牌?: 取消令牌_): 只读数组_<诊断_>;

        /**
         * Gets a 类型 checker that can be used to semantically analyze source files in the program.
         */
        获取类型检查(): 类型检查_;

        /* @internal */ 获取公共源目录(): 文字;

        // For testing purposes only.  Should not be used by any other consumers (including the
        // language service).
        /* @internal */ 获取诊断生成类型检查器(): 类型检查_;
        /* @internal */ 丢弃诊断生成类型检查器(): 无值;

        /* @internal */ 获取节点数量(): 数字;
        /* @internal */ 获取标识符数量(): 数字;
        /* @internal */ 获取符号数量(): 数字;
        /* @internal */ 获取类型数量(): 数字;

        /* @internal */ 获取文件处理诊断信息(): 诊断收集_;
        是来自外部库的源文件(文件: 源文件_): 真假;

        // For testing purposes only.
        /* @internal */ 结构被重用?: 结构被重用_;


        /** Given a source 文件, get the 名称 of the package it was imported from. */
        /* @internal */ 源文件转为包名称: 词典_<文字>;
        /** Set of all source files that some other source 文件 redirects to. */
        /* @internal */ 重定向目标集: 词典_<为真>;
        /* @internal */ 依赖模块目录: 词典_<文字>;

        获取本地模块组?(): 模块_[]
        获取外部模块组?(): 模块_[]
        /** Is the 文件 emitted 文件 */
        /* @internal */ 是输出的文件(文件: 文字): 真假;
            
        /* @internal */ 当前源码目录: 文字;
        /* @internal */ 当前模块目录: 文字;
        /* @internal */ 全局模块目录: 文字;
        /* @internal */ 当前项目配置: 文字;
    }

    /* @internal */
    导出 常量 枚举 结构被重用_ {
        非_ = 0,
        安全模块_ = 1 << 0,
        完全_ = 1 << 1,
    }

    导出 接口 自定义转换器_ {
        之前?: 转换工厂_<源文件_>[];
        之后?: 转换工厂_<源文件_>[];
    }

    导出 接口 源映射跨度_ {
        /** Line number in the .js 文件. */
        输出的行: 数字;
        /** Column number in the .js 文件. */
        输出的列: 数字;
        /** Line number in the .ts 文件. */
        源行: 数字;
        /** Column number in the .ts 文件. */
        源列数: 数字;
        /** Optional 名称 (index into names 数组) associated with this 跨度. */
        名称索引?: 数字;
        /** .ts 文件 (index into sources 数组) associated with this 跨度 */
        源索引: 数字;
    }

    导出 接口 源映射数据_ {
        源映射文件路径: 文字;           // Where the sourcemap 文件 is written
        Js源映射URL: 文字;          // source map URL written in the .js 文件
        源映射文件: 文字;               // Source map's 文件 field - .js 文件 名称
        源映射源根: 文字;         // Source map's sourceRoot field - location where the sources will be present if not ''
        源映射源组: 文字[];          // Source map's sources field - 列表 of sources that can be indexed in this source map
        源映射源内容?: 文字[];  // Source map's sourcesContent field - 列表 of the sources' 文本 to be embedded in the source map
        输入源文件组: 文字[];      // Input source 文件 (which one can use on program to get the 文件), 1:1 mapping with the sourceMapSources 列表
        源映射名称组?: 文字[];           // Source map's names field - 列表 of names that can be indexed in this source map
        源映射映射组: 文字;           // Source map's mapping field - encoded source map spans
        源映射解码映射组: 源映射跨度_[];  // Raw source map spans that were encoded into the sourceMapMappings
    }

    /** Return code used by getEmitOutput function to indicate status of the function */
    导出 枚举 退出状态_ {
        // Compiler ran successfully.  Either this was a simple do-nothing compilation (for example,
        // when -version or -help was provided, or this was a normal compilation, no diagnostics
        // were produced, and all outputs were generated successfully.
        成功_ = 0,

        // 诊断信息_ were produced and because of them no code was generated.
        诊断当前_已跳过输出_ = 1,

        // 诊断信息_ were produced and outputs were generated in spite of them.
        诊断当前_输出生成_ = 2,
    }

    导出 接口 输出结果_ {
        输出跳过: 真假;
        /** Contains declaration emit diagnostics */
        诊断组: 只读数组_<诊断_>;
        输出文件: 文字[]; // Array of files the compiler wrote to disk
        /* @internal */ 源映射: 源映射数据_[];  // Array of sourceMapData if compiler emitted sourcemaps
    }

    /* @internal */
    导出 接口 类型检查主机_ {
        获取编译选项(): 编译选项_;
        获取源文件组(): 只读数组_<源文件_>;
        获取源文件(文件名: 文字): 源文件_;            
        /* @internal */ 当前源码目录: 文字;
        /* @internal */ 当前模块目录: 文字;
        /* @internal */ 全局模块目录: 文字;
    }

    导出 接口 类型检查_ {
        getTypeOfSymbolAtLocation(符号: 符号_, n: 节点_): 类型_;
        getDeclaredTypeOfSymbol(符号: 符号_): 类型_;
        getPropertiesOfType(类型: 类型_): 符号_[];
        getPropertyOfType(类型: 类型_, 属性名: 文字): 符号_ | 未定;
        getIndexInfoOfType(类型: 类型_, 种类: IndexKind): IndexInfo | 未定;
        getSignaturesOfType(类型: 类型_, 种类: 签名种类_): 签名_[];
        getIndexTypeOfType(类型: 类型_, 种类: IndexKind): 类型_ | 未定;
        getBaseTypes(类型: 接口类型_): 基类型_[];
        getBaseTypeOfLiteralType(类型: 类型_): 类型_;
        getWidenedType(类型: 类型_): 类型_;
        getReturnTypeOfSignature(签名: 签名_): 类型_;
        /**
         * Gets the 类型 of a 参数 at a given position in a 签名.
         * Returns `any` if the index is not valid.
         */
        /* @internal */ getParameterType(签名: 签名_, parameterIndex: 数字): 类型_;
        getNullableType(类型: 类型_, 标志: 类型标志_): 类型_;
        getNonNullableType(类型: 类型_): 类型_;

        /** Note that the resulting nodes cannot be checked. */
        typeToTypeNode(类型: 类型_, enclosingDeclaration?: 节点_, 标志?: NodeBuilderFlags): 类型节点_ | 未定;
        /* @internal */ typeToTypeNode(类型: 类型_, enclosingDeclaration?: 节点_, 标志?: NodeBuilderFlags, tracker?: 符号跟踪器_): 类型节点_ | 未定; // tslint:disable-line unified-signatures
        /** Note that the resulting nodes cannot be checked. */
        signatureToSignatureDeclaration(签名: 签名_, 种类: 语法_, enclosingDeclaration?: 节点_, 标志?: NodeBuilderFlags): 签名声明_ & { 类型实参?: 节点数组_<类型节点_> } | 未定;
        /** Note that the resulting nodes cannot be checked. */
        symbolToEntityName(符号: 符号_, meaning: 符号标志_, enclosingDeclaration?: 节点_, 标志?: NodeBuilderFlags): 实体名称_ | 未定;
        /** Note that the resulting nodes cannot be checked. */
        symbolToExpression(符号: 符号_, meaning: 符号标志_, enclosingDeclaration?: 节点_, 标志?: NodeBuilderFlags): 表达式_ | 未定;
        /** Note that the resulting nodes cannot be checked. */
        symbolToParameterDeclaration(符号: 符号_, enclosingDeclaration?: 节点_, 标志?: NodeBuilderFlags): 参数声明_ | 未定;

        getSymbolsInScope(location: 节点_, meaning: 符号标志_): 符号_[];
        getSymbolAtLocation(n: 节点_): 符号_ | 未定;
        getSymbolsOfParameterPropertyDeclaration(参数: 参数声明_, 参数名: 文字): 符号_[];
        getShorthandAssignmentValueSymbol(location: 节点_): 符号_ | 未定;
        /**
         * If a 符号 is a local 符号 with an associated exported 符号, returns the exported 符号.
         * Otherwise returns its input.
         * For example, at `export 类型 T = number;`:
         *     - `getSymbolAtLocation` at the location `T` will return the exported 符号 for `T`.
         *     - But the 结果 of `getSymbolsInScope` will contain the *local* 符号 for `T`, not the exported 符号.
         *     - Calling `getExportSymbolOfSymbol` on that local 符号 will return the exported 符号.
         */
        getExportSymbolOfSymbol(符号: 符号_): 符号_;
        getPropertySymbolOfDestructuringAssignment(location: 标识符_): 符号_ | 未定;
        getTypeAtLocation(n: 节点_): 类型_;
        getTypeFromTypeNode(n: 类型节点_): 类型_;

        signatureToString(签名: 签名_, enclosingDeclaration?: 节点_, 标志?: TypeFormatFlags, 种类?: 签名种类_): 文字;
        typeToString(类型: 类型_, enclosingDeclaration?: 节点_, 标志?: TypeFormatFlags): 文字;
        symbolToString(符号: 符号_, enclosingDeclaration?: 节点_, meaning?: 符号标志_, 标志?: SymbolFormatFlags): 文字;

        /* @internal */ writeSignature(签名: 签名_, enclosingDeclaration?: 节点_, 标志?: TypeFormatFlags, 种类?: 签名种类_, writer?: 输出文本作者_): 文字;
        /* @internal */ writeType(类型: 类型_, enclosingDeclaration?: 节点_, 标志?: TypeFormatFlags, writer?: 输出文本作者_): 文字;
        /* @internal */ writeSymbol(符号: 符号_, enclosingDeclaration?: 节点_, meaning?: 符号标志_, 标志?: SymbolFormatFlags, writer?: 输出文本作者_): 文字;
        /**
         * @deprecated Use the createX factory functions or XToY typechecker methods and `createPrinter` or the `xToString` methods instead
         * This will be removed in a future version.
         */
        getSymbolDisplayBuilder(): SymbolDisplayBuilder;
        getFullyQualifiedName(符号: 符号_): 文字;
        getAugmentedPropertiesOfType(类型: 类型_): 符号_[];
        getRootSymbols(符号: 符号_): 符号_[];
        getContextualType(n: 表达式_): 类型_ | 未定;
        /* @internal */ getContextualTypeForArgumentAtIndex(call: 调用族表达式_, argIndex: 数字): 类型_;
        /* @internal */ isContextSensitive(n: 表达式_ | 方法声明_): 真假;

        /**
         * returns unknownSignature in the case of an error.
         * @param argumentCount Apparent number of arguments, passed in case of a possibly incomplete call. This should come from an ArgumentListInfo. See `signatureHelp.ts`.
         */
        getResolvedSignature(n: 调用族表达式_, candidatesOutArray?: 签名_[], argumentCount?: 数字): 签名_;
        getSignatureFromDeclaration(declaration: 签名声明_): 签名_ | 未定;
        isImplementationOfOverload(n: 签名声明_): 真假 | 未定;
        isUndefinedSymbol(符号: 符号_): 真假;
        isArgumentsSymbol(符号: 符号_): 真假;
        isUnknownSymbol(符号: 符号_): 真假;
        /* @internal */ getMergedSymbol(符号: 符号_): 符号_;

        getConstantValue(n: 属性访问表达式_ | 元素访问表达式_): 文字 | 数字 | 未定;
        isValidPropertyAccess(n: 属性访问表达式_ | 限定名_, 属性名: 文字): 真假;
        /** Exclude accesses to private 属性组 or methods with a `this` 参数 that `类型` doesn't satisfy. */
        /* @internal */ isValidPropertyAccessForCompletions(n: 属性访问表达式_, 类型: 类型_, property: 符号_): 真假;
        /** Follow all aliases to get the 原始 符号. */
        getAliasedSymbol(符号: 符号_): 符号_;
        /** Follow a *single* alias to get the immediately aliased 符号. */
        /* @internal */ getImmediateAliasedSymbol(符号: 符号_): 符号_;
        isOptionalParameter(n: 参数声明_): 真假;
        getAmbientModules(): 符号_[];

        getApparentType(类型: 类型_): 类型_;
        getSuggestionForNonexistentProperty(n: 标识符_, containingType: 类型_): 文字 | 未定;
        getSuggestionForNonexistentSymbol(location: 节点_, 名称: 文字, meaning: 符号标志_): 文字 | 未定;
        getBaseConstraintOfType(类型: 类型_): 类型_ | 未定;

        /* @internal */ getAnyType(): 类型_;
        /* @internal */ getStringType(): 类型_;
        /* @internal */ getNumberType(): 类型_;
        /* @internal */ getBooleanType(): 类型_;
        /* @internal */ getVoidType(): 类型_;
        /* @internal */ getUndefinedType(): 类型_;
        /* @internal */ getNullType(): 类型_;
        /* @internal */ getESSymbolType(): 类型_;
        /* @internal */ getNeverType(): 类型_;
        /* @internal */ getUnionType(类型组: 类型_[], subtypeReduction?: UnionReduction): 类型_;
        /* @internal */ createArrayType(元素类型: 类型_): 类型_;
        /* @internal */ createPromiseType(类型: 类型_): 类型_;

        /* @internal */ createAnonymousType(符号: 符号_, 成员: 符号表_, callSignatures: 签名_[], constructSignatures: 签名_[], stringIndexInfo: IndexInfo, numberIndexInfo: IndexInfo): 类型_;
        /* @internal */ createSignature(
            declaration: 签名声明_,
            thisParameter: 符号_ | 未定,
            参数: 符号_[],
            resolvedReturnType: 类型_,
            minArgumentCount: 数字,
            hasRestParameter: 真假,
            hasLiteralTypes: 真假,
        ): 签名_;
        /* @internal */ createSymbol(标志: 符号标志_, 名称: 文字): 临时符号_;
        /* @internal */ createIndexInfo(类型: 类型_, isReadonly: 真假, declaration?: 签名声明_): IndexInfo;
        /* @internal */ isSymbolAccessible(符号: 符号_, enclosingDeclaration: 节点_, meaning: 符号标志_, shouldComputeAliasToMarkVisible: 真假): SymbolAccessibilityResult;
        /* @internal */ 尝试查找不增加的环境模块(模块名称: 文字): 符号_ | 未定;

        /* @internal */ getSymbolWalker(accept?: (符号: 符号_) => 真假): SymbolWalker;

        // Should not be called directly.  Should only be accessed through the Program instance.
        /* @internal */ 获取诊断组(源文件?: 源文件_, 取消令牌?: 取消令牌_): 诊断_[];
        /* @internal */ 获取全局诊断(): 诊断_[];
        /* @internal */ 获取输出解析器(源文件?: 源文件_, 取消令牌?: 取消令牌_): 输出解析器_;

        /* @internal */ 获取节点数量(): 数字;
        /* @internal */ 获取标识符数量(): 数字;
        /* @internal */ 获取符号数量(): 数字;
        /* @internal */ 获取类型数量(): 数字;

        /**
         * For a union, will include a property if it's defined in *any* of the member 类型组.
         * So for `{ a } | { b }`, this will include both `a` and `b`.
         * Does not include 属性组 of primitive 类型组.
         */
        /* @internal */ isArrayLikeType(类型: 类型_): 真假;
        /* @internal */ getAllPossiblePropertiesOfTypes(类型: 只读数组_<类型_>): 符号_[];
        /* @internal */ resolveName(名称: 文字, location: 节点_, meaning: 符号标志_, excludeGlobals: 真假): 符号_ | 未定;
        /* @internal */ getJsxNamespace(location?: 节点_): 文字;

        /**
         * Note that this will return 未定 in the following case:
         *     // a.ts
         *     export namespace N { export class C { } }
         *     // b.ts
         *     <<enclosingDeclaration>>
         * Where `C` is the 符号 we're looking for.
         * This should be called in a loop climbing parents of the 符号, so we'll get `N`.
         */
        /* @internal */ getAccessibleSymbolChain(符号: 符号_, enclosingDeclaration: 节点_ | 未定, meaning: 符号标志_, useOnlyExternalAliasing: 真假): 符号_[] | 未定;

        /* @internal */ tryGetThisTypeAt(n: 节点_): 类型_ | 未定;
        /* @internal */ getTypeArgumentConstraint(n: 类型节点_): 类型_ | 未定;

        /**
         * Does *not* get *all* suggestion diagnostics, just the ones that were convenient to report in the checker.
         * Others are added in computeSuggestionDiagnostics.
         */
        /* @internal */ getSuggestionDiagnostics(文件: 源文件_): 只读数组_<诊断_>;
    }

    /* @internal */
    导出 常量 枚举 UnionReduction {
        无_ = 0,
        Literal,
        Subtype
    }

    导出 常量 枚举 NodeBuilderFlags {
        无_ = 0,
        // Options
        NoTruncation = 1 << 0,   // Don't truncate 结果
        WriteArrayAsGenericType = 1 << 1,   // Write Array<T> instead T[]
        // empty 空格_
        UseStructuralFallback = 1 << 3,   // When an alias cannot be named by its 符号, rather than report an error, fallback to a structural printout if possible
        // empty 空格_
        WriteTypeArgumentsOfSignature = 1 << 5,   // Write the 类型 arguments instead of 类型 参数 of the 签名
        UseFullyQualifiedType = 1 << 6,   // Write out the fully qualified 类型 名称 (eg. Module.类型_, instead of 类型_)
        UseOnlyExternalAliasing = 1 << 7,   // Only use external aliases for a 符号
        SuppressAnyReturnType = 1 << 8,   // If the return 类型 is any-like, don't offer a return 类型.
        WriteType参数InQualifiedName = 1 << 9,
        MultilineObjectLiterals = 1 << 10,  // Always write object literals across multiple lines
        WriteClassExpressionAsTypeLiteral = 1 << 11,  // Write class {} as { new(): {} } - used for mixin declaration emit
        UseTypeOfFunction = 1 << 12,  // Build using typeof instead of function 类型 字面量
        OmitParameterModifiers = 1 << 13,  // Omit 修饰符 on 参数
        UseAliasDefinedOutsideCurrentScope = 1 << 14,  // Allow non-visible aliases

        // Error handling
        AllowThisInObjectLiteral = 1 << 15,
        AllowQualifedNameInPlaceOfIdentifier = 1 << 16,
        AllowAnonymousIdentifier = 1 << 17,
        AllowEmptyUnionOrIntersection = 1 << 18,
        AllowEmptyTuple = 1 << 19,
        AllowUniqueESSymbolType = 1 << 20,
        AllowEmptyIndexInfoType = 1 << 21,

        IgnoreErrors = AllowThisInObjectLiteral | AllowQualifedNameInPlaceOfIdentifier | AllowAnonymousIdentifier | AllowEmptyUnionOrIntersection | AllowEmptyTuple | AllowEmptyIndexInfoType,

        // State
        InObjectTypeLiteral = 1 << 22,
        InTypeAlias = 1 << 23,    // Writing 类型 in 类型 alias declaration
        InInitialEntityName = 1 << 24,    // Set when writing the LHS of an 实体 名称 or 实体 名称 表达式
        InReverseMappedType = 1 << 25,
    }

    // Ensure the shared 标志 between this and `NodeBuilderFlags` stay in alignment
    导出 常量 枚举 TypeFormatFlags {
        无_ = 0,
        NoTruncation = 1 << 0,  // Don't truncate typeToString 结果
        WriteArrayAsGenericType = 1 << 1,  // Write Array<T> instead T[]
        // hole because there's a hole in n builder 标志
        UseStructuralFallback = 1 << 3,   // When an alias cannot be named by its 符号, rather than report an error, fallback to a structural printout if possible
        // hole because there's a hole in n builder 标志
        WriteTypeArgumentsOfSignature = 1 << 5,  // Write the 类型 arguments instead of 类型 参数 of the 签名
        UseFullyQualifiedType = 1 << 6,  // Write out the fully qualified 类型 名称 (eg. Module.类型_, instead of 类型_)
        // hole because `UseOnlyExternalAliasing` is here in n builder 标志, but functions which take old 标志 use `SymbolFormatFlags` instead
        SuppressAnyReturnType = 1 << 8,  // If the return 类型 is any-like, don't offer a return 类型.
        // hole because `WriteType参数InQualifiedName` is here in n builder 标志, but functions which take old 标志 use `SymbolFormatFlags` for this instead
        MultilineObjectLiterals = 1 << 10, // Always print object literals across multiple lines (only used to map into n builder 标志)
        WriteClassExpressionAsTypeLiteral = 1 << 11, // Write a 类型 字面量 instead of (Anonymous class)
        UseTypeOfFunction = 1 << 12, // Write typeof instead of function 类型 字面量
        OmitParameterModifiers = 1 << 13, // Omit 修饰符 on 参数
        UseAliasDefinedOutsideCurrentScope = 1 << 14, // For a `类型 T = ... ` defined in a different 文件, write `T` instead of its value,
        // even though `T` can't be accessed in the 当前 scope.

        // Error Handling
        AllowUniqueESSymbolType = 1 << 20, // This is bit 20 to align with the same bit in `NodeBuilderFlags`

        // TypeFormatFlags exclusive
        AddUndefined = 1 << 17, // Add 未定 to 类型组 of initialized, non-optional 参数
        WriteArrowStyleSignature = 1 << 18, // Write arrow style 签名

        // State
        InArrayType = 1 << 19, // Writing an 数组 元素 类型
        InElementType = 1 << 21, // Writing an 数组 or union 元素 类型
        InFirstTypeArgument = 1 << 22, // Writing 首个 类型 argument of the instantiated 类型
        InTypeAlias = 1 << 23, // Writing 类型 in 类型 alias declaration

        /** @deprecated */ WriteOwnNameForAnyLike = 0,  // Does nothing

        NodeBuilderFlagsMask = NoTruncation | WriteArrayAsGenericType | UseStructuralFallback | WriteTypeArgumentsOfSignature | UseFullyQualifiedType | SuppressAnyReturnType | MultilineObjectLiterals | WriteClassExpressionAsTypeLiteral | UseTypeOfFunction | OmitParameterModifiers | UseAliasDefinedOutsideCurrentScope | AllowUniqueESSymbolType | InTypeAlias,
    }

    导出 常量 枚举 SymbolFormatFlags {
        无_ = 0x00000000,

        // Write symbols's 类型 argument if it is instantiated 符号
        // eg. class C<T> { p: T }   <-- Show p as C<T>.p here
        //     var a: C<number>;
        //     var p = a.p; <--- Here p is property of C<number> so show it as C<number>.p instead of just C.p
        写类型参数或参数_ = 0x00000001,

        // Use only external alias information to get the 符号 名称 in the given 上下文
        // eg.  module m { export class c { } } import x = m.c;
        // When this flag is specified m.c will be used to refer to the class instead of alias 符号 x
        UseOnlyExternalAliasing = 0x00000002,

        // Build 符号 名称 using any nodes needed, instead of just components of an 实体 名称
        AllowAnyNodeKind = 0x00000004,

        // Prefer aliases which are not directly visible
        UseAliasDefinedOutsideCurrentScope = 0x00000008,
    }

    /* @internal */
    导出 接口 SymbolWalker {
        /** Note: Return values are not ordered. */
        walkType(root: 类型_): { visitedTypes: 只读数组_<类型_>, visitedSymbols: 只读数组_<符号_> };
        /** Note: Return values are not ordered. */
        walkSymbol(root: 符号_): { visitedTypes: 只读数组_<类型_>, visitedSymbols: 只读数组_<符号_> };
    }

    /**
     * @deprecated
     */
    导出 接口 SymbolDisplayBuilder {
        /** @deprecated */ buildTypeDisplay(类型: 类型_, writer: 符号作者_, enclosingDeclaration?: 节点_, 标志?: TypeFormatFlags): 无值;
        /** @deprecated */ buildSymbolDisplay(符号: 符号_, writer: 符号作者_, enclosingDeclaration?: 节点_, meaning?: 符号标志_, 标志?: SymbolFormatFlags): 无值;
        /** @deprecated */ buildIndexSignatureDisplay(info: IndexInfo, writer: 符号作者_, 种类: IndexKind, enclosingDeclaration?: 节点_, globalFlags?: TypeFormatFlags, symbolStack?: 符号_[]): 无值;
        /** @deprecated */ buildParameterDisplay(参数: 符号_, writer: 符号作者_, enclosingDeclaration?: 节点_, 标志?: TypeFormatFlags): 无值;
        /** @deprecated */ buildTypeParameterDisplayFromSymbol(符号: 符号_, writer: 符号作者_, enclosingDeclaration?: 节点_, 标志?: TypeFormatFlags): 无值;
        /** @deprecated */ buildDisplayFor参数AndDelimiters(thisParameter: 符号_, 参数: 符号_[], writer: 符号作者_, enclosingDeclaration?: 节点_, 标志?: TypeFormatFlags): 无值;

        /** @deprecated */ buildReturnTypeDisplay(签名: 签名_, writer: 符号作者_, enclosingDeclaration?: 节点_, 标志?: TypeFormatFlags): 无值;
    }

    /**
     * @deprecated Migrate to other methods of generating 符号 names, ex symbolToEntityName + a printer or symbolToString
     */
    导出 接口 符号作者_ 扩展 符号跟踪器_ {
        writeKeyword(文本: 文字): 无值;
        writeOperator(文本: 文字): 无值;
        writePunctuation(文本: 文字): 无值;
        writeSpace(文本: 文字): 无值;
        writeStringLiteral(文本: 文字): 无值;
        writeParameter(文本: 文字): 无值;
        writeProperty(文本: 文字): 无值;
        writeSymbol(文本: 文字, 符号: 符号_): 无值;
        writeLine(): 无值;
        increaseIndent(): 无值;
        decreaseIndent(): 无值;
        clear(): 无值;
    }

    /* @internal */
    导出 常量 枚举 SymbolAccessibility {
        Accessible,
        NotAccessible,
        CannotBeNamed
    }

    /* @internal */
    导出 常量 枚举 SyntheticSymbolKind {
        UnionOrIntersection,
        Spread
    }

    导出 常量 枚举 TypePredicateKind {
        This,
        标识符_
    }

    导出 接口 TypePredicateBase {
        种类: TypePredicateKind;
        类型: 类型_;
    }

    导出 接口 ThisTypePredicate 扩展 TypePredicateBase {
        种类: TypePredicateKind.This;
    }

    导出 接口 IdentifierTypePredicate 扩展 TypePredicateBase {
        种类: TypePredicateKind.标识符_;
        参数名: 文字;
        parameterIndex: 数字;
    }

    /* @internal */
    导出 接口 SymbolVisibilityResult {
        accessibility: SymbolAccessibility;
        errorSymbolName?: 文字; // Optional 符号 名称 that results in error
        errorNode?: 节点_; // optional n that results in error
    }

    /* @internal */
    导出 接口 SymbolAccessibilityResult 扩展 SymbolVisibilityResult {
        errorModuleName?: 文字; // If the 符号 is not visible from module, module's 名称
    }

    /** Indicates how to serialize the 名称 for a 类型引用节点_ when emitting decorator metadata */
    /* @internal */
    导出 枚举 TypeReferenceSerializationKind {
        未知_,                            // The 类型引用节点_ could not be resolved. The 类型 名称
        // should be emitted using a safe fallback.
        TypeWithConstructSignatureAndValue, // The 类型引用节点_ resolves to a 类型 with a constructor
        // function that can be reached at runtime (e.g. a `class`
        // declaration or a `var` declaration for the static side
        // of a 类型, such as the global `Promise` 类型 in lib.d.ts).
        VoidNullableOrNeverType,            // The 类型引用节点_ resolves to a Void-like, Nullable, or Never 类型.
        NumberLikeType,                     // The 类型引用节点_ resolves to a Number-like 类型.
        StringLikeType,                     // The 类型引用节点_ resolves to a String-like 类型.
        BooleanType,                        // The 类型引用节点_ resolves to a Boolean-like 类型.
        ArrayLikeType,                      // The 类型引用节点_ resolves to an Array-like 类型.
        ESSymbolType,                       // The 类型引用节点_ resolves to the ESSymbol 类型.
        Promise,                            // The 类型引用节点_ resolved to the global Promise constructor 符号.
        TypeWithCallSignature,              // The 类型引用节点_ resolves to a 函数_ 类型 or a 类型
        // with call signatures.
        对象类型_,                         // The 类型引用节点_ resolves to any other 类型.
    }

    /* @internal */
    导出 接口 输出解析器_ {
        hasGlobalName(名称: 文字): 真假;
        getReferencedExportContainer(n: 标识符_, prefixLocals?: 真假): 源文件_;
        getReferencedImportDeclaration(n: 标识符_): 声明_;
        getReferencedDeclarationWithCollidingName(n: 标识符_): 声明_;
        isDeclarationWithCollidingName(n: 声明_): 真假;
        isValueAliasDeclaration(n: 节点_): 真假;
        isReferencedAliasDeclaration(n: 节点_, checkChildren?: 真假): 真假;
        getNodeCheckFlags(n: 节点_): NodeCheckFlags;
        isDeclarationVisible(n: 声明_): 真假;
        collectLinkedAliases(n: 标识符_): 节点_[];
        isImplementationOfOverload(n: 函数族声明_): 真假 | 未定;
        isRequiredInitializedParameter(n: 参数声明_): 真假;
        isOptionalUninitializedParameterProperty(n: 参数声明_): 真假;
        writeTypeOfDeclaration(declaration: 变量族声明_, enclosingDeclaration: 节点_, 标志: TypeFormatFlags, writer: 输出文本作者_): 无值;
        writeReturnTypeOfSignatureDeclaration(signatureDeclaration: 签名声明_, enclosingDeclaration: 节点_, 标志: TypeFormatFlags, writer: 输出文本作者_): 无值;
        writeTypeOfExpression(expr: 表达式_, enclosingDeclaration: 节点_, 标志: TypeFormatFlags, writer: 输出文本作者_): 无值;
        isSymbolAccessible(符号: 符号_, enclosingDeclaration: 节点_, meaning: 符号标志_, shouldComputeAliasToMarkVisible: 真假): SymbolAccessibilityResult;
        isEntityNameVisible(实体名称: 实体名或实体名表达式_, enclosingDeclaration: 节点_): SymbolVisibilityResult;
        // Returns the constant value this property access resolves to, or '未定' for a non-constant
        getConstantValue(n: 属性访问表达式_ | 元素访问表达式_): 文字 | 数字;
        getReferencedValueDeclaration(reference: 标识符_): 声明_;
        getTypeReferenceSerializationKind(类型名: 实体名称_, location?: 节点_): TypeReferenceSerializationKind;
        isOptionalParameter(n: 参数声明_): 真假;
        moduleExportsSomeValue(moduleReferenceExpression: 表达式_): 真假;
        获取外部模块文件从声明(declaration: 导入从声明_ | 导入声明_): 源文件_;
        isArgumentsLocalBinding(n: 标识符_): 真假;
        getTypeReferenceDirectivesForEntityName(名称: 实体名或实体名表达式_): 文字[];
        getTypeReferenceDirectivesForSymbol(符号: 符号_, meaning?: 符号标志_): 文字[];
        isLiteralConstDeclaration(n: 变量声明_ | 属性声明_ | 参数声明_): 真假;
        writeLiteralConstValue(n: 变量声明_ | 属性声明_ | 参数声明_, writer: 输出文本作者_): 无值;
        getJsxFactoryEntity(location?: 节点_): 实体名称_;
    }

    导出 常量 枚举 符号标志_ {
        无_ = 0,
        变量_ = 1 << 1,   // A 块-scoped variable (let or const)
        常量_ = 1<< 2,
        属性_ = 1 << 3,   // Property
        程序_ = 1 << 4,
        启动程序_ = 1 << 5,
        函数_ = 1 << 6,
        函数签名_ = 1 << 7,   // 函数_
        启动函数_ = 1 << 8,
        初始函数_ = 1 << 9,
        创建函数签名_ = 1 << 10,
        结构_ = 1 << 11,
        接口_ = 1 << 12,   // Interface
        结构字面量_ = 1 << 13,  // Object Literal
        方法_ = 1 << 14,  // Method
        方法签名_ = 1 << 15,
        函数类型_ = 1 << 16,  // Call, construct, or index 签名
        类型别名_ = 1 << 17,  // 类型_ alias
        类型声明_ = 1 << 18,
        类型字面量_ = 1 << 19,
        别名_ = 1 << 20,  // An alias for another 符号 (see 注释 in isAliasSymbolDeclaration in checker)
        类型参数_ = 1 << 21,
        临时的_ = 1 << 22,  // Transient 符号 (created during 类型 check)
        枚举_ = 1 << 23,
        枚举成员_ = 1 << 24, 

        /* @internal */
        全部_ = 变量_ | 常量_ | 属性_ | 程序_ | 枚举_ | 枚举成员_ | 启动程序_ | 类型参数_ | 函数_ | 启动函数_ | 初始函数_ | 函数签名_ | 创建函数签名_ | 结构字面量_ | 方法_ | 方法签名_ | 别名_ | 函数类型_ | 结构_ | 接口_ | 类型别名_ | 临时的_ | 类型声明_ | 类型字面量_,

        值_ = 变量_ | 常量_ | 属性_  | 枚举_ | 枚举成员_ | 程序_ | 启动程序_ | 函数_ | 启动函数_ | 初始函数_ | 函数签名_ | 创建函数签名_ | 方法_ | 方法签名_ | 别名_,

        类型_ = 接口_ | 结构_ | 枚举_ | 函数类型_ | 类型别名_ | 类型声明_ | 类型字面量_ | 结构字面量_ | 类型参数_ ,

        变量排除_ = 值_,

        参数排除_ = 值_ | 类型参数_,
        属性排除_ = 全部_,
        函数排除_ = 全部_,
        方法排除_ = 全部_,
        方法签名排除_ = 全部_,
        创建函数排除_ = 全部_ & ~创建函数签名_,
        初始函数排除_ = 全部_ & ~初始函数_,
        函数签名排除_ = 函数排除_ & ~函数签名_,
        接口排除_ = 全部_,
        结构排除_ = 全部_,
        类型别名排除_ = 全部_,
        类型声明排除_ = 全部_,
        类型参数排除_ = 类型_ | 属性_ | 变量_,
        别名排除_ = 值_,
        具有成员_ = 接口_ | 结构_ | 结构字面量_ | 程序_ | 枚举_,
        枚举成员排除 = 全部_,
        枚举排除_ = 全部_,
        /* @internal */
        延迟绑定容器_ = 接口_ | 结构字面量_,
    }

    导出 接口 符号_ {
        标志: 符号标志_;                     // 符号_ 标志
        名称: 文字;                  // Name of 符号
        声明组?: 声明_[];           // Declarations associated with this 符号
        方法集合?: 词典_<符号表_>;
        启动符号?: 符号_
        初始声明组?:符号_[]
        值声明: 声明_;         // First value declaration of the 符号
        成员?: 符号表_;                  // Class, interface or 字面量 instance 成员
        导出表?: 符号表_;                  // Module 导出表
        全局导出表?: 符号表_;            // Conditional global UMD 导出表
        /* @internal */ id?: 数字;            // Unique id (used to look up SymbolLinks)
        /* @internal */ 合并Id?: 数字;       // Merge id (used to look up merged 符号)
        /* @internal */ 父符号?: 符号_;        // Parent 符号
        /* @internal */ 导出符号?: 符号_;  // Exported 符号 associated with this 符号
        /* @internal */ 是被引用的?: 符号标志_; // 真_ if the 符号 is referenced elsewhere. Keeps track of the meaning of a reference in case a 符号 is both a 类型 参数 and 参数.
        /* @internal */ 是赋值的?: 真假;   // 真_ if the 符号 is a 参数 with assignments
    }

    /* @internal */
    导出 接口 SymbolLinks {
        immediateTarget?: 符号_;           // Immediate 目标 of an alias. May be another alias. Do not access directly, use `checker.getImmediateAliasedSymbol` instead.
        目标?: 符号_;                    // Resolved (non-alias) 目标 of an alias
        类型?: 类型_;                        // 类型_ of value 符号
        映射?: 类型映射_,                // Type 映射 for instantiation alias
        常量或枚举常量值?:数字|文字
        uniqueESSymbolType?: 类型_;          // UniqueESSymbol 类型 for a 符号
        declaredType?: 类型_;                // 类型_ of class, interface, enum, 类型 alias, or 类型 参数
        inferredClassType?: 类型_;           // 类型_ of an inferred ES5 class
        instantiations?: 词典_<类型_>;         // Instantiations of generic 类型 alias (未定 if non-generic)
        referenced?: 真假;               // 真_ if alias 符号 has been referenced as a value
        containingType?: 联合类型_; // Containing union or intersection 类型 for synthetic property
        leftSpread?: 符号_;                // Left source for synthetic spread property
        rightSpread?: 符号_;               // Right source for synthetic spread property
        syntheticOrigin?: 符号_;           // For a property on a mapped or spread 类型, points back to the 原始 property
        isDiscriminantProperty?: 真假;   // 真_ if discriminant synthetic property
        resolvedExports?: 符号表_;      // Resolved 导出表 of module or combined early- and late-bound static 成员 of a class.
        resolvedMembers?: 符号表_;      // Combined early- and late-bound 成员 of a 符号
        exportsChecked?: 真假;           // 真_ if 导出表 of external module have been checked
        类型参数检查?: 真假;    // 真_ if 类型 参数 of merged class and interface 声明组 have been checked.
        isDeclarationWithCollidingName?: 真假;   // 真_ if 符号 is 块 scoped redeclaration
        exportsSomeValue?: 真假;         // 真_ if module 导出表 some value (not just 类型组)
        enumKind?: EnumKind;                // Enum declaration classification
        lateSymbol?: 符号_;                // Late-bound 符号 for a computed property
        nameType?: 类型_;                    // 类型_ associate with a late-bound or mapped 类型 property 符号's 名称
        匿名缓存?: 词典_<为真>;
        类型参数? :只读数组_<类型参数_>        
        outerTypeParameters?: 类型参数_[];  // Outer type parameters of anonymous object type
    }

    /* @internal */
    导出 常量 枚举 EnumKind {
        Numeric,                            // Numeric enum (each member has a 类型标志.Enum 类型)
        Literal                             // Literal enum (each member has a 类型标志.EnumLiteral 类型)
    }

    /* @internal */
    导出 常量 枚举 CheckFlags {
        Instantiated = 1 << 0,         // Instantiated 符号
        SyntheticProperty = 1 << 1,         // Property in union or intersection 类型
        SyntheticMethod = 1 << 2,         // Method in union or intersection 类型
        Readonly = 1 << 3,         // Readonly transient 符号
        Partial = 1 << 4,         // Synthetic property present in some but not all constituents
        HasNonUniformType = 1 << 5,         // Synthetic property with non-uniform 类型 in constituents
        ContainsPublic = 1 << 6,         // Synthetic property with public constituent(s)
        ContainsProtected = 1 << 7,         // Synthetic property with protected constituent(s)
        ContainsPrivate = 1 << 8,         // Synthetic property with private constituent(s)
        ContainsStatic = 1 << 9,         // Synthetic property with static constituent(s)
        Late = 1 << 10,        // Late-bound 符号 for a computed property with a dynamic 名称
        ReverseMapped = 1 << 11,        // property of reverse-inferred homomorphic mapped 类型.        
        RestParameter     = 1 << 14,        // Rest parameter
        Synthetic = SyntheticProperty | SyntheticMethod
    }

    /* @internal */
    导出 接口 临时符号_ 扩展 符号_, SymbolLinks {
        checkFlags: CheckFlags;
    }

    /** 符号表_ based on ES6 Map interface. */
    导出 类型 符号表_ = 词典_<符号_>;

    /** Represents a '前缀*后缀' 模式. */
    /* @internal */
    导出 接口 模式_ {
        前缀: 文字;
        后缀: 文字;
    }

    /* @internal */
    导出 常量 枚举 NodeCheckFlags {
        TypeChecked = 0x00000001,  // 节点_ has been 类型 checked
        LexicalThis = 0x00000002,  // Lexical 'this' reference
        CaptureThis = 0x00000004,  // Lexical 'this' used in 主体
        CaptureNewTarget = 0x00000008,  // Lexical 'new.目标' used in 主体
        SuperInstance = 0x00000100,  // Instance 'super' reference
        SuperStatic = 0x00000200,  // Static 'super' reference
        ContextChecked = 0x00000400,  // Contextual 类型组 have been assigned
        AsyncMethodWithSuper = 0x00000800,  // An async method that reads a value from a member of 'super'.
        AsyncMethodWithSuperBinding = 0x00001000,  // An async method that assigns a value to a member of 'super'.
        CaptureArguments = 0x00002000,  // Lexical 'arguments' used in 主体
        EnumValuesComputed = 0x00004000,  // Values for enum 成员 have been computed, and any errors have been reported for them.
        LexicalModuleMergesWithClass = 0x00008000,  // Instantiated lexical module declaration is merged with a previous class declaration.
        LoopWithCapturedBlockScopedBinding = 0x00010000,  // Loop that contains 块 scoped variable captured in closure
        CapturedBlockScopedBinding = 0x00020000,  // 块_-scoped binding that is captured in some function
        BlockScopedBindingInLoop = 0x00040000,  // 块_-scoped binding with declaration nested inside iteration 语句
        ClassWithBodyScopedClassBinding = 0x00080000,  // Decorated class that contains a binding to itself inside of the class 主体.
        BodyScopedClassBinding = 0x00100000,  // Binding to a decorated class inside of the class's 主体.
        NeedsLoopOutParameter = 0x00200000,  // 块_ scoped binding whose value should be explicitly copied outside of the converted loop
        AssignmentsMarked = 0x00400000,  // 参数_ assignments have been marked
        ClassWithConstructorReference = 0x00800000,  // Class that contains a binding to its constructor inside of the class 主体.
        ConstructorReferenceInClass = 0x01000000,  // Binding to a class constructor inside of the class's 主体.
    }

    /* @internal */
    导出 接口 NodeLinks {
        标志?: NodeCheckFlags;           // Set of 标志 specific to 节点_
        resolvedType?: 类型_;              // Cached 类型 of 类型 n
        resolvedSignature?: 签名_;    // Cached 签名 of 签名 n or call 表达式
        解析的符号?: 符号_;          // Cached 名称 resolution 结果
        resolvedIndexInfo?: IndexInfo;    // Cached indexing info resolution 结果
        maybeTypePredicate?: 真假;     // Cached check whether call 表达式 might reference a 类型 predicate
        enumMemberValue?: 文字 | 数字;  // Constant value of enum member
        isVisible?: 真假;              // Is this n visible
        containsArgumentsReference?: 真假; // Whether a function-like declaration contains an 'arguments' reference
        hasReportedStatementInAmbientContext?: 真假;  // Cache boolean if we report 语句组 in ambient 上下文
        resolvedJsxElementAttributesType?: 类型_;  // resolved 元素 特性组 类型 of a JSX openinglike 元素
        resolvedJsxElementAllAttributesType?: 类型_;  // resolved all 元素 特性组 类型 of a JSX openinglike 元素
        hasSuperCall?: 真假;           // recorded 结果 when we try to find super-call. We only try to find one if this flag is 未定, indicating that we haven't made an attempt.
        switchTypes?: 类型_[];             // Cached 数组 of switch case 表达式 类型组
        解析的初始化表达式?:表达式_
        解析的别名符号?:符号_
        完成接口成员合并?: 真假
    }

    导出 常量 枚举 类型标志_ {
        未知_ = 1 << 0,
        无值_ = 1 << 1,
        通用_ = 1 << 2,
        数字类型_ = 1 << 3,
        复合类型_ = 1 << 4,  // 指针 数组 列表 通信 只读通信 只写通信
        词典类型_ = 1 << 5,
        文本类型_ = 1 << 6,
        真假类型_ = 1 << 7,
        真类型_ = 1 << 8,
        假类型_ = 1 << 9,
        对象_ = 1 << 10,  // Object 类型
        联合_ = 1 << 11,  // Union (T | U)
        交叉_ = 1 << 12,
        类型参数_ = 1 << 13,
        未定_ = 1 << 14,  // 类型_ is or contains 未定 or null widening 类型
        ContainsWideningType    = 1 << 24,  // Type is or contains undefined or null widening type
        /* @internal */
        ContainsObjectLiteral   = 1 << 25,  // Type is or contains object literal type
        /* @internal */
        ContainsAnyFunctionType = 1 << 26,  // Type is or contains the anyFunctionType
        /* @internal */
        新字面量类型_ = 1 << 29,  // Fresh 字面量 or unique 类型
        结构化类型_ = 对象_ | 联合_ | 交叉_,        
        PropagatingFlags = ContainsWideningType | ContainsObjectLiteral | ContainsAnyFunctionType,
    }

    // Properties common to all 类型组
    导出 接口 类型_ {
        标志: 类型标志_;                // Flags
        /* @internal */ id: 数字;      // Unique ID
        /* @internal */ 检查者: 类型检查_;
        符号?: 符号_;                 // 符号_ associated with 类型 (if any)
        aliasSymbol?: 符号_;            // Alias associated with 类型
        aliasTypeArguments?: 类型_[];         
        /* @internal */ aliasTypeArgumentsContainsMarker?: 真假;   // Alias type arguments (if any)
        /* @internal */
        permissiveInstantiation?: 类型_;  // Instantiation with type parameters mapped to wildcard type
        /* @internal */
        restrictiveInstantiation?: 类型_; // Instantiation with type parameters mapped to unconstrained form
        /* @internal */
        immediateBaseConstraint?: 类型_;  // Immediate base constraint cache
    }

    /* @internal */
    // Intrinsic 类型组 (类型标志.Intrinsic)
    导出 接口 内置类型_ 扩展 类型_ {
        名称: 文字;        // Name of intrinsic 类型
    }

    导出 接口 复合类型_ 扩展 类型_{
        复合标志: 复合标志_
        基础类型: 类型_
    }

    导出 常量 枚举 复合标志_ {
        指针类型_ = 1 << 1,
        列表类型_ = 1 << 2,
        数组类型_ = 1 << 3,
        通信类型_ = 1 << 4,
        只读通信类型_ = 1 << 5,
        只写通信类型_ = 1 << 6,
    }

    导出 接口 真假类型_ 扩展 内置类型_, 联合类型_ { }

    导出 接口 真类型 扩展 内置类型_ { }

    导出 接口 假类型 扩展 内置类型_ { }

    导出 常量 枚举 数字标志_ {
        整数8_ = 1 << 0,
        整数16_ = 1 << 1,
        整数32_ = 1 << 2,
        整数64_ = 1 << 3,
        正整数8_ = 1 << 4,
        正整数16_ = 1 << 5,
        正整数32_ = 1 << 6,
        正整数64_ = 1 << 7,
        小数32_ = 1 << 8,
        小数64_ = 1 << 9,
        虚数32_ = 1 << 10,
        虚数64_ = 1 << 11,
        复数64_ = 1 << 12,
        复数128_ = 1 << 13,
    }

    导出 接口 数字类型_ 扩展 内置类型_ {
        数字标志: 数字标志_
    }

    导出 接口 整数类型_ 扩展 数字类型_ {}
    导出 接口 小数类型_ 扩展 数字类型_ {}
    
    导出 接口 无符号指针类型_ 扩展 数字类型_ { }

    导出 接口 字节类型_ 扩展 数字类型_ { }

    导出 接口 字符类型_ 扩展 数字类型_ { }

    导出 接口 复数类型_ 扩展 数字类型_ {
        实数类型: 小数类型_
        虚数类型: 小数类型_
    }

    导出 接口 指针类型_ 扩展 复合类型_ {
        基础类型: 类型_
    }

    导出 接口 通信类型_ 扩展 复合类型_ {
        基础类型: 类型_
        容量: 数字
    }

    导出 接口 只读通信类型_ 扩展 复合类型_ {
        基础类型: 类型_
        容量: 数字
    }

    导出 接口 只写通信类型_ 扩展 复合类型_ {
        基础类型: 类型_
        容量: 数字
    }

    导出 接口 列表类型_ 扩展 复合类型_ {
        基础类型: 类型_
        长度: 数字
        容量: 数字
    }

    导出 接口 数组类型_ 扩展 复合类型_ {
        基础类型: 类型_
        长度: 数字 | 未定
    }

    导出 接口 文本类型_ 扩展 数组类型_{ }

    导出 接口 词典类型_ 扩展 类型_ {
        键类型: 类型_
        值类型: 类型_
        容量?: 数字
    }

    导出 常量 枚举 对象标志_ {
        未知_ = 0,
        接口_ = 1 << 0,  // Interface
        结构_ = 1 << 1,
        定义_ = 1 << 2,
        匿名_ = 1 << 3,
        程序_ = 1 << 4,
        枚举_ = 1 << 5,
        枚举成员_ = 1 << 6,
        引用_ = 1 << 7,
        返回值_ = 1 << 8,
        字面量_ = 1 << 9,
        标记类型_ = 1 << 10,
    }
    
    导出 接口 对象类型_ 扩展 类型_ {
        对象标志: 对象标志_;
    }

    导出 接口 结构类型_ 扩展 对象类型_ {
        类型参数: 类型参数_[];           // Type parameters (undefined if non-generic)
        thisType?: 类型参数_
    }
    
    导出 接口 定义类型_ 扩展 结构类型_{
        基础类型: 类型_
        类型名称: 文字
    }

    导出 接口 结构类型包括声明成员_ 扩展 结构类型_{
        声明属性组: 符号_[];              // Declared members
        方法组: 符号表_;
    }

    导出 接口 可实例化类型_ 扩展 类型_ {
        /* @internal */
        解析基约束?: 类型_;
    }
    
    导出 接口 接口类型_ 扩展 对象类型_ {
        类型参数: 类型参数_[];      // Type parameters (undefined if non-generic)        
        thisType?: 类型参数_
    }

    导出 接口 程序类型_ 扩展 对象类型_ {}

    导出 接口 返回值类型_ 扩展 对象类型_ {}

    导出 接口 匿名类型_ 扩展 对象类型_ {
        目标?: 匿名类型_
        映射?: 类型映射_
    }
    // Object 类型 or intersection of object 类型组
    导出 类型 基类型_ = 对象类型_;

    /**
     * 类型_ references (对象标志_.Reference). When a class or interface has 类型 参数 or
     * a 'this' 类型, references to the class or interface are made using 类型 references. The
     * 类型实参 property specifies the 类型组 to substitute for the 类型 参数 of the
     * class or interface and optionally includes an extra 元素 that specifies the 类型 to
     * substitute for 'this' in the resulting instantiation. When no extra argument is present,
     * the 类型 reference itself is substituted for 'this'. The 类型实参 property is 未定
     * if the class or interface has no 类型 参数 and the reference isn't specifying an
     * explicit 'this' argument.
     */

    导出 接口 类型引用_ 扩展 对象类型_ {
        目标: 泛型类型_;    // 类型_ reference 目标
        类型实参?: 类型_[];  // Type reference type arguments (undefined if none)
    }

    导出 类型 类型映射_ = (T: 类型参数_)=> 类型_

    导出 接口 类型参数_ 扩展 可实例化类型_{
        约束: 类型_
        默认: 类型_
        目标?: 类型参数_;  // Instantiation 目标 
        映射: 类型映射_
        isThisType?:真假
        解析基约束: 类型_
    }

    /* @internal */
    导出 常量 枚举 Variance {
        Invariant = 0,  // Neither covariant nor contravariant
        Covariant = 1,  // Covariant
        Contravariant = 2,  // Contravariant
        Bivariant = 3,  // Both covariant and contravariant
        Independent = 4,  // Unwitnessed 类型 参数
    }

    
    导出 接口 联合或交叉类型_ 扩展 类型_ {
        类型组: 类型_[];                    // Constituent types
        /* @internal */
        propertyCache: 符号表_       // Cache of resolved properties
        /* @internal */
        resolvedProperties: 符号_[];
        /* @internal */
        解析基约束: 类型_;
        /* @internal */
        couldContainTypeVariables: 真假;
    }

    导出 接口 交叉类型_ 扩展 联合或交叉类型_ {
        /* @internal */
        resolvedApparentType: 类型_;
    }

    导出 接口 联合类型_ 扩展 联合或交叉类型_ {
        类型组: 类型_[];                    // Constituent 类型组
        /* @internal */
        propertyCache: 符号表_;            // Cache of resolved 属性组
        /* @internal */
        resolvedProperties: 符号_[];
    }

    导出 类型 结构化类型_ = 对象类型_ | 联合类型_ | 交叉类型_;

    /* @internal */
    // Resolved object, union, or intersection 类型
    导出 接口 解析类型_ 扩展 对象类型_, 联合类型_ {
        成员: 符号表_;              // Properties by 名称
        属性组: 符号_[];              // Properties
        调用签名组?: 签名_[];       // Call signatures of 类型
        方法组: 符号表_;
    }

    /* @internal */
    // Object literals are initially marked fresh. Freshness disappears following an assignment,
    // before a 类型 assertion, or when an object 字面量's 类型 is widened. The regular
    // version of a fresh 类型 is identical except for the 类型标志.FreshObjectLiteral flag.
    导出 接口 新鲜结构字面量类型_ 扩展 解析类型_ {
        常规类型: 解析类型_;  // Regular version of fresh 类型
    }

    导出 接口 泛型类型_ 扩展 结构类型_, 类型引用_ {
        /* @internal */
        instantiations: 词典_<类型引用_>;  // Generic instantiation cache
        /* @internal */
        variances?: Variance[];  // Variance of each type parameter
    }

    导出 常量 枚举 签名种类_ {
        Call,
        Construct,
    }

    导出 接口 签名_ {
        declaration: 签名声明_;  // Originating declaration
        typeParameters?: 类型参数_[];
        参数: 符号_[];               // 参数
        /* @internal */
        // See 注释 in `instantiateSignature` for why these are set lazily.
        resolvedReturnType: 类型_ | 未定; // Lazily set by `getReturnTypeOfSignature`.
        /* @internal */
        // Lazily set by `getTypePredicateOfSignature`.
        // `未定` indicates a 类型 predicate that has not yet been computed.
        // Uses a special `noTypePredicate` sentinel value to indicate that there is no 类型 predicate. This looks like a 类型谓词_ at runtime to avoid polymorphism.
        /* @internal */
        minArgumentCount: 数字;           // Number of non-optional 参数
        /* @internal */
        具有剩余参数: 真假;          // 真_ if 最后的 参数 is rest 参数
        /* @internal */
        目标?: 签名_;                 // Instantiation 目标
        映射?: 类型映射_;
        /* @internal */
        unionSignatures?: 签名_[];      // Underlying signatures of a union 签名
        /* @internal */
        erasedSignatureCache?: 签名_;   // Erased version of 签名 (deferred)
        /* @internal */
        canonicalSignatureCache?: 签名_; // Canonical version of 签名 (deferred)
        /* @internal */
        isolatedSignatureType?: 对象类型_; // A manufactured 类型 that just contains the 签名 for purposes of 签名 comparison
        /* @internal */
        instantiations?: 词典_<签名_>;    // Generic 签名 instantiation cache
    }

    导出 常量 枚举 IndexKind {
        String,
        Number,
    }

    导出 接口 IndexInfo {
        类型: 类型_;
        isReadonly: 真假;
        declaration?: 签名声明_;
    }

    导出 常量 枚举 InferencePriority {
        NakedTypeVariable = 1 << 0,  // Naked 类型 variable in union or intersection 类型
        HomomorphicMappedType = 1 << 1,  // Reverse inference for homomorphic mapped 类型
        MappedTypeConstraint = 1 << 2,  // Reverse inference for mapped 类型
        ReturnType = 1 << 3,  // Inference made from return 类型 of generic function
        NoConstraints = 1 << 4,  // Don't infer from constraints of instantiable 类型组
        AlwaysStrict = 1 << 5,  // Always use strict rules for contravariant inferences

        PriorityImpliesUnion = ReturnType | MappedTypeConstraint,  // These priorities imply that the resulting 类型 should be a union of all candidates
    }

    /* @internal */
    导出 接口 推断信息_ {
        类型参数: 类型参数_
        candidates: 类型_[];            // Candidates in covariant positions (or 未定)
        contraCandidates: 类型_[];      // Candidates in contravariant positions (or 未定)
        inferredType: 类型_;            // Cache for resolved inferred 类型
        priority: InferencePriority;   // Priority of 当前 inference set
        topLevel: 真假;             // 真_ if all inferences are to top level occurrences
        isFixed: 真假;              // 真_ if inferences are fixed
    }

    /* @internal */
    导出 常量 枚举 InferenceFlags {
        无_ = 0,  // No special inference behaviors
        InferUnionTypes = 1 << 0,  // Infer union 类型组 for disjoint candidates (otherwise unknownType)
        NoDefault = 1 << 1,  // Infer unknownType for no inferences (otherwise anyType or emptyObjectType)
        AnyDefault = 1 << 2,  // Infer anyType for no inferences (otherwise emptyObjectType)
    }

    /**
     * Ternary values are defined such that
     * x & y is 假_ if either x or y is 假_.
     * x & y is Maybe if either x or y is Maybe, but neither x or y is 假_.
     * x & y is 真_ if both x and y are 真_.
     * x | y is 假_ if both x and y are 假_.
     * x | y is Maybe if either x or y is Maybe, but neither x or y is 真_.
     * x | y is 真_ if either x or y is 真_.
     */
    /* @internal */
    导出 常量 枚举 Ternary {
        假_ = 0,
        也许_ = 1,
        真_ = -1
    }

    /* @internal */
    导出 类型 类型比较器_ = (s: 类型_, t: 类型_, 报告错误?: 真假) => Ternary;

    /* @internal */
    导出 接口 推断上下文_  扩展 类型映射_ {        
        类型参数: 类型参数_[];    // Type parameters for which inferences are made
        签名: 签名_;               // Generic 签名 for which inferences are made (if any)
        inferences: 推断信息_[];        // Inferences made for each 类型 参数
        标志: InferenceFlags;              // Inference 标志
        compareTypes: 类型比较器_;         // 类型_ comparer function
    }

    /* @internal */
    导出 接口 WideningContext {
        父节点?: WideningContext;            // Parent 上下文
        属性名?: 文字;             // Name of property in 父节点
        siblings?: 类型_[];                   // Types of siblings
        resolvedPropertyNames?: 文字[];  // Property names occurring in sibling object literals
    }

    /* @internal */
    导出 常量 枚举 特殊属性赋值种类_ {
        无_,
        /// 导出表.名称 = expr
        ExportsProperty,
        /// module.导出表 = expr
        模块导出_,
        /// className.prototype.名称 = expr
        PrototypeProperty,
        /// this.名称 = expr
        ThisProperty,
        // F.名称 = expr
        Property,
        // F.prototype = { ... }
        Prototype,
    }


    导出 接口 诊断信息_ {
        键: 文字;
        级别: 诊断级别_;
        代码: 数字;
        消息: 文字;
        不需要报告?: {};
    }

    /**
     * A linked 列表 of formatted diagnostic messages to be used as part of a multiline 消息.
     * It is built from the bottom up, leaving the 头部 to be the 'main' diagnostic.
     * While it seems that DiagnosticMessageChain is structurally similar to 诊断信息_,
     * the difference is that messages are all preformatted in DMC.
     */
    导出 接口 诊断信息链_ {
        消息文本: 文字;
        级别: 诊断级别_;
        代码: 数字;
        下个?: 诊断信息链_;
    }

    导出 接口 诊断_ {
        文件: 源文件_ | 未定;
        开始: 数字 | 未定;
        _长度: 数字 | 未定;
        消息文本: 文字 | 诊断信息链_;
        级别: 诊断级别_;
        代码: 数字;
        源码?: 文字;
    }

    导出 枚举 诊断级别_ {
        警告_,
        错误_,
        建议_,
        消息_
    }

    导出 接口 诊断包括位置_ 扩展 诊断_ {
        文件: 源文件_;
        开始: 数字;
        _长度: 数字;
    }

    /* @internal */
    导出 函数 诊断类别名称(d: { 级别: 诊断级别_ }, 小写 = 为真): 文字 {
        常量 名称 = 诊断级别_[d.级别];
        返回 小写 ? 名称.转为小写() : 名称;
    }

    导出 类型 编译选项值_ = 文字 | 数字 | 真假 | (文字 | 数字)[] | 文字[] | 词典族_<文字[]> | 空值 | 未定;

    导出 接口 编译选项_ {
        // 命令行命令
        初始?: 真假;
        帮助?: 真假;
        版本?: 真假;
        监控?: 真假;
        // 编译选项
        系统?: 'win' | 'linux' | 'darwin',
        架构?: '368' | 'amd64' | 'arm';
        定义?: 文字[];
        字符?: 文字;
        彩色?: 真假;
        输出?: 路径_;
        启用诊断?: 真假;
        根目录?: 文字;
        扩展的诊断组?: 真假;
        保留监控输出?: 真假;
        打印文件列表?: 真假;
        允许未使用标签?:真假;
        允许无法访问代码?:真假;
        [选项: 文字]: 编译选项值_ | 未定;
    }

    导出 常量 枚举 NewLineKind {
        CarriageReturnLineFeed = 0,
        LineFeed = 1
    }

    导出 接口 行和字符_ {
        /** 0-based. */
        行: 数字;
        /*
         * 0-based. This value denotes the character position in line and is different from the 'column' because of 水平制表号_ characters.
         */
        字符: 数字;
    }

    导出 常量 枚举 脚本种类_ {
        未知_ = 0,
        K = 1,
        DK = 2,
        TestK = 3,
    }

    导出 常量 枚举 脚本目标_ {
        win_amd64 = 0,
        win_368 = 1,
        darwin_amd64 = 2,
        darwin_386 = 3,
        linux_amd64 = 4,
        linux_arm = 5,
        linux_386 = 6
    }

    导出 常量 枚举 语言版本_ {
        标准_,
        K,
    }

    /* @internal */
    导出 常量 枚举 诊断样式_ {
        简单的_,
        漂亮的_,
    }

    /** Either a parsed command line or a parsed tsconfig.json */
    导出 接口 解析命令行_ {
        选项组?: 编译选项_;
        文件名组?: 文字[];
        错误?: 诊断_[];
        保存时编译?: 真假;
    }

    导出 常量 枚举 监控目录标志_ {
        无_ = 0,
        递归_ = 1 << 0,
    }

    /* @internal */
    导出 接口 命令行选项基类_ {
        名称: 文字;
        类型: '文字' | '数字' | '真假' | '对象' | '列表' | 词典_<数字 | 文字>;    // a value of a primitive 类型, or an object 字面量 mapping named values to actual values
        是文件路径?: 真假;                                   // 真_ if option value is a 路径 or 文件名
        短名?: 文字;                                     // A short mnemonic for convenience - for instance, 'h' can be used in place of 'help'
        描述?: 诊断信息_;                        // The 消息 describing what the command line switch does
        参数类型?: 诊断信息_;                          // The 名称 to be used for a non-boolean option's 参数
        是仅Klang配置?: 真假;                               // 真_ if option can only be specified via tsconfig.json 文件
        是命令行仅?: 真假;
        显示在简化帮助视图?: 真假;
        诊断级别?: 诊断信息_;
    }

    /* @internal */
    导出 接口 基本命令行选项_ 扩展 命令行选项基类_ {
        类型: '文字' | '数字' | '真假';
    }

    /* @internal */
    导出 接口 自定义命令行选项_ 扩展 命令行选项基类_ {
        类型: 词典_<数字 | 文字>;  // an object 字面量 mapping named values to actual values
    }

    /* @internal */
    导出 接口 Klang配置选项_ 扩展 命令行选项基类_ {
        类型: '对象';
        元素选项?: 词典_<命令行选项_>;
        附加键诊断信息?: 诊断信息_;
    }

    /* @internal */
    导出 接口 列表类型命令行选项_ 扩展 命令行选项基类_ {
        类型: '列表';
        元素: 自定义命令行选项_ | 基本命令行选项_ | Klang配置选项_;
    }

    /* @internal */
    导出 类型 命令行选项_ = 自定义命令行选项_ | 基本命令行选项_ | Klang配置选项_ | 列表类型命令行选项_;

    /* @internal */
    导出 常量 枚举 字符_ {
        空字符_ = 0,
        最大Ascii字符_ = 0x7F,

        换行符_ = 0x0A,               // \n
        回车符_ = 0x0D,               // \r
        行分隔符_ = 0x2028,
        段落分隔符_ = 0x2029,
        下一行_ = 0x0085,

        // Unicode 3.0 空格_ characters
        空格_ = 0x0020,   // ' '
        不间断空格_ = 0x00A0,   //
        半角四空_ = 0x2000,
        全角四空_ = 0x2001,
        半角空格_ = 0x2002,
        全角空格_ = 0x2003,
        三分之一全角空格_ = 0x2004,
        四分之一全角空格_ = 0x2005,
        六分之一全角空格_ = 0x2006,
        数字空格_ = 0x2007,
        标点空格_ = 0x2008,
        超薄空格_ = 0x2009,
        超细空格_ = 0x200A,
        零宽度空格_ = 0x200B,
        窄无换行空格_ = 0x202F,
        表意空格_ = 0x3000,
        数学模型空格_ = 0x205F,
        欧甘符_ = 0x1680,

        _ = 0x5F,
        $ = 0x24,

        _0 = 0x30,
        _1 = 0x31,
        _2 = 0x32,
        _3 = 0x33,
        _4 = 0x34,
        _5 = 0x35,
        _6 = 0x36,
        _7 = 0x37,
        _8 = 0x38,
        _9 = 0x39,

        a = 0x61,
        b = 0x62,
        c = 0x63,
        d = 0x64,
        e = 0x65,
        f = 0x66,
        g = 0x67,
        h = 0x68,
        i = 0x69,
        j = 0x6A,
        k = 0x6B,
        l = 0x6C,
        m = 0x6D,
        n = 0x6E,
        o = 0x6F,
        p = 0x70,
        q = 0x71,
        r = 0x72,
        s = 0x73,
        t = 0x74,
        u = 0x75,
        v = 0x76,
        w = 0x77,
        x = 0x78,
        y = 0x79,
        z = 0x7A,

        A = 0x41,
        B = 0x42,
        C = 0x43,
        D = 0x44,
        E = 0x45,
        F = 0x46,
        G = 0x47,
        H = 0x48,
        I = 0x49,
        J = 0x4A,
        K = 0x4B,
        L = 0x4C,
        M = 0x4D,
        N = 0x4E,
        O = 0x4F,
        P = 0x50,
        Q = 0x51,
        R = 0x52,
        S = 0x53,
        T = 0x54,
        U = 0x55,
        V = 0x56,
        W = 0x57,
        X = 0x58,
        Y = 0x59,
        Z = 0x5a,

        且号_ = 0x26,             // &
        星号_ = 0x2A,             // *
        艾特号_ = 0x40,           // @
        反斜杠号_ = 0x5C,         // \
        反引号_ = 0x60,           // `
        或号_ = 0x7C,             // |
        异或号_ = 0x5E,           // ^
        右大括号_ = 0x7D,         // }
        右方括号_ = 0x5D,         // ]
        右括号_ = 0x29,           // )
        冒号_ = 0x3A,             // :
        逗号_ = 0x2C,             // ,
        点号_ = 0x2E,             // .
        双引号_ = 0x22,           // '
        等号_ = 0x3D,             // =
        叹号_ = 0x21,             // !
        右尖括号_ = 0x3E,          // >
        井号_ = 0x23,             // #
        左尖括号_ = 0x3C,         // <
        减号_ = 0x2D,             // -
        左大括号_ = 0x7B,         // {
        左方括号_ = 0x5B,         // [
        左括号_ = 0x28,           // (
        百分号_ = 0x25,           // %
        加号_ = 0x2B,             // +
        问号_ = 0x3F,             // ?
        分号_ = 0x3B,             // ;
        单引号_ = 0x27,           // '
        斜杠号_ = 0x2F,           // /
        波折号_ = 0x7E,           // ~

        退格号_ = 0x08,           // \b
        分页号_ = 0x0C,           // \f
        字节顺序标记_ = 0xFEFF,
        水平制表号_ = 0x09,        // \t
        垂直制表号_ = 0x0B,        // \v
        定_ = 0x5B9A,
        义_ = 0x4E49,
        结_ = 0x7ED3,
        束_ = 0x675F,
    }

    导出 接口 模块解析主机_ {
        文件存在(文件名: 文字): 真假;
        // readFile function is used to read arbitrary 文本 files on disk, i.e. when resolution procedure needs the 内容 of 'package.json'
        // to determine location of bundled typings for n module
        读文件(文件名: 文字): 文字 | 未定;
        跟踪?(s: 文字): 无值;
        目录存在?(目录名称: 文字): 真假;
        /**
         * Resolve a symbolic link.
         * @see https://nodejs.org/api/fs.html#fs_fs_realpathsync_path_options
         */
        真实路径?(路径: 文字): 文字;
        获取当前目录?(): 文字;

        获取目录组?(路径: 文字): 文字[];        
        /* @internal */ 当前源码目录: 文字;
        /* @internal */ 当前模块目录: 文字;
        /* @internal */ 全局模块目录: 文字;
        /* @internal */ 当前项目配置: 文字;
    }

    /**
     * Unique 标识符 with a package 名称 and version.
     * If changing this, remember to change `packageIdIsEqual`.
     */
    导出 接口 包Id_ {
        名称: 文字;
        /** Version of the package, e.g. '1.2.3' */
        版本: 文字;
    }

    导出 常量 枚举 扩展名_ {
        K = '.k',
        DK = '.d.k',
        TestK = '.test.k'
    }

    导出 接口 解析模块包括失败的查找位置_ {
        只读 模块目录路径?: 解析的模块名称_ | 未定;
    }

    /* @internal */
    导出 类型 有已失效的解析_ = (源文件: 路径_) => 真假;

    导出 接口 编译主机_ 扩展 模块解析主机_ {
        获取源文件(文件名: 文字, 正在错误?: (消息: 文字) => 无值, 应创建新源文件?: 真假): 源文件_ | 未定;
        获取源文件从路径?(文件名: 文字, 路径: 路径_, 正在错误?: (消息: 文字) => 无值, 应创建新源文件?: 真假): 源文件_ | 未定;
        获取取消令牌?(): 取消令牌_;
        获取默认支持库文件名(): 文字;
        获取默认支持库位置?(): 文字;
        写文件: 写文件回调_;
        获取当前目录(): 文字;
        获取目录组(路径: 文字): 文字[];
        读目录(路径: 文字, 扩展组?: 只读数组_<文字>, 深度?: 数字): 文字[];
        获取规范文件名称(文件名: 文字): 文字;
        使用区分大小写文件名(): 真假;
        获取新行(): 文字;

        /*
         * 编译主机_ must either implement resolveModuleNames (in case if it wants to be completely in charge of
         * module 名称 resolution) or provide implementation for methods from 模块解析主机_ (in this case compiler
         * will apply built-in module resolution logic and use 成员 of 模块解析主机_ to ask host specific questions).
         * If resolveModuleNames is implemented then implementation for 成员 from 模块解析主机_ can be just
         * 'throw new Error('NotImplemented')'
         */
        解析模块名称组?(模块名称: 文字[], 包含文件: 文字, 重复使用名称?: 文字[]): (解析的模块名称_ | 未定)[];

        获取环境变量?(名称: 文字): 文字;
        /* @internal */ 正在发布旧源文件?(旧源文件: 源文件_, 旧选项: 编译选项_): 无值;
        /* @internal */ 具有失效解析?: 有已失效的解析_;
        /* @internal */ 具有更改诊断类型指令名称?: 真假;
        创建哈希?(数据: 文字): 文字;
    }

    导出 接口 源码映射范围_ 扩展 文本范围_ {
        源?: 源码映射源码_;
    }

    导出 接口 源码映射源码_ {
        文件名: 文字;
        文本: 文字;
        /* @internal */ 行词典: 只读数组_<数字>;
        跳过杂项?: (首位: 数字) => 数字;
    }

    /* @internal */
    导出 接口 输出节点_ {
        带注释的节点组?: 节点_[];                 // Tracks Parse-tree nodes with EmitNodes for eventual cleanup.
        标志?: 输出标志_;                       // Flags that customize emit
        前导注释?: 合成注释_[];  // Synthesized leading 注释组
        尾随注释?: 合成注释_[]; // Synthesized trailing 注释组
        注释范围?: 文本范围_;                // The 文本 range to use when emitting leading or trailing 注释组
        源映射范围?: 源码映射范围_;         // The 文本 range to use when emitting leading or trailing source mappings
        令牌源映射范围?: 源码映射范围_[]; // The 文本 range to use when emitting source mappings for tokens
        常量值?: 文字 | 数字;         // The constant value of an 表达式
        外部帮助器模块名称?: 标识符_;  // The local 名称 for an imported helpers module
        助手?: 输出助手_[];                  // Emit helpers for the n
        开始在新行?: 真假;               // If the n should begin on a new line
    }

    导出 常量 枚举 输出标志_ {
        SingleLine = 1 << 0,                    // The contents of this n should be emitted on a single line.
        AdviseOnEmitNode = 1 << 1,              // The printer should invoke the onEmitNode callback when printing this n.
        NoSubstitution = 1 << 2,                // Disables further substitution of an 表达式.
        CapturesThis = 1 << 3,                  // The function captures a lexical `this`
        无前导源映射_ = 1 << 4,            // Do not emit a leading source map location for this n.
        无尾随源映射_ = 1 << 5,           // Do not emit a trailing source map location for this n.
        NoSourceMap = 无前导源映射_ | 无尾随源映射_, // Do not emit a source map location for this n.
        无嵌套源映射_ = 1 << 6,            // Do not emit source map locations for children of this n.
        无令牌前导源映射_ = 1 << 7,      // Do not emit leading source map location for 令牌 nodes.
        无令牌尾随源映射_ = 1 << 8,     // Do not emit trailing source map location for 令牌 nodes.
        NoTokenSourceMaps = 无令牌前导源映射_ | 无令牌尾随源映射_, // Do not emit source map locations for tokens of this n.
        NoLeadingComments = 1 << 9,             // Do not emit leading 注释组 for this n.
        NoTrailingComments = 1 << 10,           // Do not emit trailing 注释组 for this n.
        NoComments = NoLeadingComments | NoTrailingComments, // Do not emit 注释组 for this n.
        NoNestedComments = 1 << 11,
        HelperName = 1 << 12,
        ExportName = 1 << 13,                   // Ensure an export 前缀 is added for an 标识符 that points to an exported declaration with a local 名称 (see 符号标志_.ExportHasLocal).
        LocalName = 1 << 14,                    // Ensure an export 前缀 is not added for an 标识符 that points to an exported declaration.
        InternalName = 1 << 15,                 // The 名称 is internal to an ES5 class 主体 function.
        Indented = 1 << 16,                     // Adds an explicit extra indentation level for class and function bodies when printing (used to match old emitter).
        NoIndentation = 1 << 17,                // Do not 缩进 the n.
        AsyncFunctionBody = 1 << 18,
        ReuseTempVariableScope = 1 << 19,       // Reuse the existing temp variable scope during emit.
        CustomPrologue = 1 << 20,               // Treat the 语句 as if it were a prologue directive (NOTE: Prologue directives are *not* transformed).
        NoHoisting = 1 << 21,                   // Do not hoist this declaration in --module system
        HasEndOfDeclarationMarker = 1 << 22,    // 声明_ has an associated 不输出语句_ to mark the 尾位 of the declaration
        Iterator = 1 << 23,                     // The 表达式 to a `yield*` should be treated as an Iterator when down-leveling, not an Iterable.
        NoAsciiEscaping = 1 << 24,              // When synthesizing nodes that lack an 原始 n or 文本源码节点, we want to write the 文本 on the n with ASCII escaping substitutions.
        /*@internal*/ TypeScriptClassWrapper = 1 << 25, // The n is an IIFE class wrapper created by the ts transform.
        /*@internal*/ NeverApplyImportHelper = 1 << 26, // Indicates the n should never be wrapped with an import star helper (because, for example, it imports tslib itself)
    }

    导出 接口 输出助手_ {
        只读 名称: 文字;      // A unique 名称 for this helper.
        只读 范围: 真假;   // Indicates whether the helper MUST be emitted in the 当前 scope.
        只读 文本: 文字;      // ES3-compatible raw script 文本.
        只读 优先级?: 数字; // Helpers with a higher priority are emitted earlier than other helpers on the n.
    }

    /**
     * Used by the checker, this enum keeps track of external emit helpers that should be 类型
     * checked.
     */
    /* @internal */
    导出 常量 枚举 外部输出助手_ {
        Extends = 1 << 0,               // __extends (used by the ES2015 class transformation)
        Assign = 1 << 1,                // __assign (used by Jsx and ESNext object spread transformations)
        Rest = 1 << 2,                  // __rest (used by ESNext object rest transformation)
        Decorate = 1 << 3,              // __decorate (used by TypeScript 装饰组 transformation)
        Metadata = 1 << 4,              // __metadata (used by TypeScript 装饰组 transformation)
        Param = 1 << 5,                 // __param (used by TypeScript 装饰组 transformation)
        Awaiter = 1 << 6,               // __awaiter (used by ES2017 async functions transformation)
        Generator = 1 << 7,             // __generator (used by ES2015 generator transformation)
        Values = 1 << 8,                // __values (used by ES2015 for..of and yield* transformations)
        Read = 1 << 9,                  // __read (used by ES2015 iterator destructuring transformation)
        Spread = 1 << 10,               // __spread (used by ES2015 数组 spread and argument 列表 spread transformations)
        Await = 1 << 11,                // __await (used by ES2017 async generator transformation)
        AsyncGenerator = 1 << 12,       // __asyncGenerator (used by ES2017 async generator transformation)
        AsyncDelegator = 1 << 13,       // __asyncDelegator (used by ES2017 async generator yield* transformation)
        AsyncValues = 1 << 14,          // __asyncValues (used by ES2017 for..await..of transformation)
        ExportStar = 1 << 15,           // __exportStar (used by CommonJS/AMD/UMD module transformation)
        MakeTemplateObject = 1 << 16,   // __makeTemplateObject (used for constructing 模板 string 数组 objects)
        FirstEmitHelper = Extends,
        LastEmitHelper = MakeTemplateObject,

        // Helpers included by ES2015 for..of
        ForOfIncludes = Values,

        // Helpers included by ES2017 for..await..of
        ForAwaitOfIncludes = AsyncValues,

        // Helpers included by ES2017 async generators
        AsyncGeneratorIncludes = Await | AsyncGenerator,

        // Helpers included by yield* in ES2017 async generators
        AsyncDelegatorIncludes = Await | AsyncDelegator | AsyncValues,

        // Helpers included by ES2015 spread
        SpreadIncludes = Read | Spread,

    }

    导出 常量 枚举 输出提示_ {
        源文件_,          // Emitting a 源文件_
        表达式_,          // Emitting an 表达式_
        标识符名称_,      // Emitting an IdentifierName
        映射类型参数_, // Emitting a 类型参数声明_ inside of a 映射类型节点_
        未指定_,         // Emitting an otherwise unspecified n
    }

    /* @internal */
    导出 接口 输出主机_ 扩展 脚本引用主机_ {
        获取源文件组(): 只读数组_<源文件_>;

        /* @internal */
        是来自外部库的源文件(文件: 源文件_): 真假;

        获取公共源目录(): 文字;
        获取规范文件名称(文件名: 文字): 文字;
        获取新行(): 文字;

        是输出阻塞(输出文件名称: 文字): 真假;

        写文件: 写文件回调_;
    }

    导出 接口 转换上下文_ {
        /*@internal*/ getEmitResolver(): 输出解析器_;
        /*@internal*/ getEmitHost(): 输出主机_;

        /** Gets the compiler options supplied to the transformer. */
        获取编译选项(): 编译选项_;

        /** Starts a new lexical environment. */
        startLexicalEnvironment(): 无值;

        /** Suspends the 当前 lexical environment, usually after visiting a 参数 列表. */
        suspendLexicalEnvironment(): 无值;

        /** Resumes a suspended lexical environment, usually before visiting a function 主体. */
        resumeLexicalEnvironment(): 无值;

        /** Ends a lexical environment, returning any 声明组. */
        endLexicalEnvironment(): 语句_[];

        /** Hoists a function declaration to the containing scope. */
        hoistFunctionDeclaration(n: 函数声明_): 无值;

        /** Hoists a variable declaration to the containing scope. */
        hoistVariableDeclaration(n: 标识符_): 无值;

        /** Records a request for a non-scoped emit helper in the 当前 上下文. */
        requestEmitHelper(helper: 输出助手_): 无值;

        /** Gets and resets the requested non-scoped emit helpers. */
        readEmitHelpers(): 输出助手_[] | 未定;

        /** Enables 表达式 substitutions in the pretty printer for the provided 语法_. */
        enableSubstitution(种类: 语法_): 无值;

        /** Determines whether 表达式 substitutions are 启用 for the provided n. */
        isSubstitutionEnabled(n: 节点_): 真假;

        /**
         * Hook used by transformers to substitute expressions just before they
         * are emitted by the pretty printer.
         *
         * NOTE: Transformation hooks should only be modified during `转换者_` initialization,
         * before returning the `NodeTransformer` callback.
         */
        onSubstituteNode: (hint: 输出提示_, n: 节点_) => 节点_;

        /**
         * Enables before/after emit notifications in the pretty printer for the provided
         * 语法_.
         */
        enableEmitNotification(种类: 语法_): 无值;

        /**
         * Determines whether before/after emit notifications should be raised in the pretty
         * printer when it emits a n.
         */
        isEmitNotificationEnabled(n: 节点_): 真假;

        /**
         * Hook used to allow transformers to capture 状态 before or after
         * the printer emits a n.
         *
         * NOTE: Transformation hooks should only be modified during `转换者_` initialization,
         * before returning the `NodeTransformer` callback.
         */
        onEmitNode: (hint: 输出提示_, n: 节点_, emitCallback: (hint: 输出提示_, n: 节点_) => 无值) => 无值;
    }

    导出 接口 转换结果_<T 扩展 节点_> {
        /** Gets the transformed source files. */
        transformed: T[];

        /** Gets diagnostics for the transformation. */
        diagnostics?: 诊断_[];

        /**
         * Gets a substitute for a n, if one is available; otherwise, returns the 原始 n.
         *
         * @param hint A hint as to the intended usage of the n.
         * @param n The n to substitute.
         */
        substituteNode(hint: 输出提示_, n: 节点_): 节点_;

        /**
         * Emits a n with possible notification.
         *
         * @param hint A hint as to the intended usage of the n.
         * @param n The n to emit.
         * @param emitCallback A callback used to emit the n.
         */
        emitNodeWithNotification(hint: 输出提示_, n: 节点_, emitCallback: (hint: 输出提示_, n: 节点_) => 无值): 无值;

        /**
         * Clean up 输出节点_ entries on any parse-tree nodes.
         */
        dispose(): 无值;
    }

    /**
     * A function that is used to initialize and return a `转换者_` callback, which in turn
     * will be used to transform one or more nodes.
     */
    导出 类型 转换工厂_<T 扩展 节点_> = (上下文: 转换上下文_) => 转换者_<T>;

    /**
     * A function that transforms a n.
     */
    导出 类型 转换者_<T 扩展 节点_> = (n: T) => T;

    /**
     * A function that accepts and possibly transforms a n.
     */
    导出 类型 访问者_ = (n: 节点_) => 访问结果_<节点_>;

    导出 类型 访问结果_<T 扩展 节点_> = T | T[] | 未定;

    导出 接口 打印机_ {
        /**
         * Print a n and its subtree as-is, without any emit transformations.
         * @param hint A value indicating the purpose of a n. This is primarily used to
         * distinguish between an `标识符_` used in an 表达式 position, versus an
         * `标识符_` used as an `IdentifierName` as part of a declaration. For most nodes you
         * should just pass `Unspecified`.
         * @param n The n to print. The n and its subtree are printed as-is, without any
         * emit transformations.
         * @param 源文件 A source 文件 that provides 上下文 for the n. The source 文本 of
         * the 文件 is used to emit the 原始 source 内容 for literals and 标识符组, while
         * the 标识符组 of the source 文件 are used when generating unique names to avoid
         * collisions.
         */
        printNode(hint: 输出提示_, n: 节点_, 源文件: 源文件_): 文字;
        /**
         * Prints a 列表 of nodes using the given format 标志
         */
        printList<T 扩展 节点_>(format: ListFormat, 列表: 节点数组_<T>, 源文件: 源文件_): 文字;
        /**
         * Prints a source 文件 as-is, without any emit transformations.
         */
        printFile(源文件: 源文件_): 文字;
        /**
         * Prints a bundle of source files as-is, without any emit transformations.
         */
        printBundle(bundle: 源文件集_): 文字;
        /*@internal*/ writeNode(hint: 输出提示_, n: 节点_, 源文件: 源文件_ | 未定, writer: 输出文本作者_): 无值;
        /*@internal*/ writeList<T 扩展 节点_>(format: ListFormat, 列表: 节点数组_<T>, 源文件: 源文件_ | 未定, writer: 输出文本作者_): 无值;
        /*@internal*/ writeFile(源文件: 源文件_, writer: 输出文本作者_): 无值;
        /*@internal*/ writeBundle(bundle: 源文件集_, writer: 输出文本作者_): 无值;
    }

    导出 接口 打印机助手_ {
        /**
         * A hook used by the 打印机_ when generating unique names to avoid collisions with
         * globally defined names that exist outside of the 当前 source 文件.
         */
        hasGlobalName?(名称: 文字): 真假;
        /**
         * A hook used by the 打印机_ to provide notifications prior to emitting a n. A
         * compatible implementation **must** invoke `emitCallback` with the provided `hint` and
         * `n` values.
         * @param hint A hint indicating the intended purpose of the n.
         * @param n The n to emit.
         * @param emitCallback A callback that, when invoked, will emit the n.
         * @example
         * ```ts
         * var printer = createPrinter(printerOptions, {
         *   onEmitNode(hint, n, emitCallback) {
         *     // set up or track 状态 prior to emitting the n...
         *     emitCallback(hint, n);
         *     // restore 状态 after emitting the n...
         *   }
         * });
         * ```
         */
        onEmitNode?(hint: 输出提示_, n: 节点_, emitCallback: (hint: 输出提示_, n: 节点_) => 无值): 无值;
        /**
         * A hook used by the 打印机_ to perform just-in-time substitution of a n. This is
         * primarily used by n transformations that need to substitute one n for another,
         * such as replacing `myExportedVar` with `导出表.myExportedVar`.
         * @param hint A hint indicating the intended purpose of the n.
         * @param n The n to emit.
         * @example
         * ```ts
         * var printer = createPrinter(printerOptions, {
         *   substituteNode(hint, n) {
         *     // perform substitution if necessary...
         *     return n;
         *   }
         * });
         * ```
         */
        substituteNode?(hint: 输出提示_, n: 节点_): 节点_;
        /*@internal*/ onEmitSourceMapOfNode?: (hint: 输出提示_, n: 节点_, emitCallback: (hint: 输出提示_, n: 节点_) => 无值) => 无值;
        /*@internal*/ onEmitSourceMapOfToken?: (n: 节点_, 令牌: 语法_, writer: (s: 文字) => 无值, 首位: 数字, emitCallback: (令牌: 语法_, writer: (s: 文字) => 无值, 首位: 数字) => 数字) => 数字;
        /*@internal*/ onEmitSourceMapOfPosition?: (首位: 数字) => 无值;
        /*@internal*/ onEmitHelpers?: (n: 节点_, writeLines: (文本: 文字) => 无值) => 无值;
        /*@internal*/ onSetSourceFile?: (n: 源文件_) => 无值;
        /*@internal*/ onBeforeEmitNodeArray?: (nodes: 节点数组_<任意>) => 无值;
        /*@internal*/ onAfterEmitNodeArray?: (nodes: 节点数组_<任意>) => 无值;
        /*@internal*/ onBeforeEmitToken?: (n: 节点_) => 无值;
        /*@internal*/ onAfterEmitToken?: (n: 节点_) => 无值;
    }

    导出 接口 打印机选项_ {
        removeComments?: 真假;
        newLine?: NewLineKind;
        omitTrailingSemicolon?: 真假;
        /*@internal*/ sourceMap?: 真假;
        /*@internal*/ inlineSourceMap?: 真假;
        /*@internal*/ extendedDiagnostics?: 真假;
    }

    /* @internal */
    导出 接口 输出文本作者_ 扩展 符号作者_ {
        write(s: 文字): 无值;
        writeTextOfNode(文本: 文字, n: 节点_): 无值;
        获取文本(): 文字;
        rawWrite(s: 文字): 无值;
        writeLiteral(s: 文字): 无值;
        获取文本首位(): 数字;
        获取行(): 数字;
        获取列(): 数字;
        getIndent(): 数字;
        isAtStartOfLine(): 真假;
    }

    /** @deprecated See 注释 on 符号作者_ */
    // Note: this has non-deprecated internal uses.
    导出 接口 符号跟踪器_ {
        // Called when the 符号 writer encounters a 符号 to write.  Currently only used by the
        // declaration emitter to help determine if it should patch up the final declaration 文件
        // with import 语句组 it previously saw (but chose not to emit).
        trackSymbol?(符号: 符号_, enclosingDeclaration?: 节点_, meaning?: 符号标志_): 无值;
        reportInaccessibleThisError?(): 无值;
        reportPrivateInBaseOfClassExpression?(属性名: 文字): 无值;
        reportInaccessibleUniqueSymbolError?(): 无值;
    }

    导出 接口 文本跨度_ {
        开始: 数字;
        长度: 数字;
    }

    导出 接口 文本改变范围_ {
        跨度: 文本跨度_;
        新长度: 数字;
    }

    导出 接口 排序数组_<T> 扩展 数组_<T> {
        ' __sortedArrayBrand': 任意;
    }

    导出 接口 排序只读数组_<T> 扩展 只读数组_<T> {
        ' __sortedArrayBrand': 任意;
    }

    /* @internal */
    导出 接口 诊断收集_ {
        // Adds a diagnostic to this diagnostic collection.
        添加(诊断: 诊断_): 无值;

        // Gets all the diagnostics that aren't associated with a 文件.
        获取全局诊断(): 诊断_[];

        // If 文件名 is provided, gets all the diagnostics associated with that 文件 名称.
        // Otherwise, returns all the diagnostics (global and 文件 associated) in this collection.
        获取诊断(文件名?: 文字): 诊断_[];

        // Gets a count of how many times this collection has been modified.  This value changes
        // each time 'add' is called (regardless of whether or not an equivalent diagnostic was
        // already in the collection).  As such, it can be used as a simple way to tell if any
        // operation caused diagnostics to be returned by storing and comparing the return value
        // of this method before/after the operation is performed.
        获取修改计数(): 数字;

        /* @internal */ 重新附加文件诊断(新文件: 源文件_): 无值;
    }

    // 语法_.语法列表_
    导出 接口 语法列表_ 扩展 节点_ {
        _子节点: 节点_[];
    }

    导出 常量 枚举 ListFormat {
        无_ = 0,
        // Line separators
        SingleLine = 0,                 // Prints the 列表 on a single line (默认).
        MultiLine = 1 << 0,             // Prints the 列表 on multiple lines.
        PreserveLines = 1 << 1,         // Prints the 列表 using line preservation if possible.
        LinesMask = SingleLine | MultiLine | PreserveLines,

        // Delimiters
        NotDelimited = 0,               // There is no delimiter between 列表 items (默认).
        BarDelimited = 1 << 2,          // Each 列表 item is 空格_-and-bar (' |') delimited.
        AmpersandDelimited = 1 << 3,    // Each 列表 item is 空格_-and-且号_ (' &') delimited.
        CommaDelimited = 1 << 4,        // Each 列表 item is 逗号_ (',') delimited.
        DelimitersMask = BarDelimited | AmpersandDelimited | CommaDelimited,

        AllowTrailingComma = 1 << 5,    // Write a trailing 逗号_ (',') if present.

        // Whitespace
        Indented = 1 << 6,              // The 列表 should be indented.
        SpaceBetweenBraces = 1 << 7,    // Inserts a 空格_ after the opening brace and before the closing brace.
        SpaceBetweenSiblings = 1 << 8,  // Inserts a 空格_ between each sibling n.

        // Brackets/Braces
        Braces = 1 << 9,                // The 列表 is surrounded by '{' and '}'.
        Parenthesis = 1 << 10,          // The 列表 is surrounded by '(' and ')'.
        AngleBrackets = 1 << 11,        // The 列表 is surrounded by '<' and '>'.
        SquareBrackets = 1 << 12,       // The 列表 is surrounded by '[' and ']'.
        BracketsMask = Braces | Parenthesis | AngleBrackets | SquareBrackets,

        OptionalIfUndefined = 1 << 13,  // Do not emit brackets if the 列表 is 未定.
        OptionalIfEmpty = 1 << 14,      // Do not emit brackets if the 列表 is empty.
        Optional = OptionalIfUndefined | OptionalIfEmpty,

        // Other
        PreferNewLine = 1 << 15,        // Prefer adding a LineTerminator between synthesized nodes.
        NoTrailingNewLine = 1 << 16,    // Do not emit a trailing NewLine for a MultiLine 列表.
        NoInterveningComments = 1 << 17, // Do not emit 注释组 between each n

        NoSpaceIfEmpty = 1 << 18,       // If the 字面量 is empty, do not add spaces between braces.
        SingleElement = 1 << 19,

        // Precomputed Formats
        Modifiers = SingleLine | SpaceBetweenSiblings | NoInterveningComments,
        HeritageClauses = SingleLine | SpaceBetweenSiblings,
        SingleLineTypeLiteralMembers = SingleLine | SpaceBetweenBraces | SpaceBetweenSiblings | Indented,
        MultiLineTypeLiteralMembers = MultiLine | Indented,

        TupleTypeElements = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented,
        UnionTypeConstituents = BarDelimited | SpaceBetweenSiblings | SingleLine,
        IntersectionTypeConstituents = AmpersandDelimited | SpaceBetweenSiblings | SingleLine,
        ObjectBindingPatternElements = SingleLine | AllowTrailingComma | SpaceBetweenBraces | CommaDelimited | SpaceBetweenSiblings | NoSpaceIfEmpty,
        ArrayBindingPatternElements = SingleLine | AllowTrailingComma | CommaDelimited | SpaceBetweenSiblings | NoSpaceIfEmpty,
        ObjectLiteralExpressionProperties = PreserveLines | CommaDelimited | SpaceBetweenSiblings | SpaceBetweenBraces | Indented | Braces | NoSpaceIfEmpty,
        ArrayLiteralExpressionElements = PreserveLines | CommaDelimited | SpaceBetweenSiblings | AllowTrailingComma | Indented | SquareBrackets,
        CommaListElements = CommaDelimited | SpaceBetweenSiblings | SingleLine,
        CallExpressionArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Parenthesis,
        NewExpressionArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Parenthesis | OptionalIfUndefined,
        TemplateExpressionSpans = SingleLine | NoInterveningComments,
        SingleLineBlockStatements = SpaceBetweenBraces | SpaceBetweenSiblings | SingleLine,
        MultiLineBlockStatements = Indented | MultiLine,
        变量声明列表_ = CommaDelimited | SpaceBetweenSiblings | SingleLine,
        SingleLineFunctionBodyStatements = SingleLine | SpaceBetweenSiblings | SpaceBetweenBraces,
        MultiLineFunctionBodyStatements = MultiLine,
        ClassHeritageClauses = SingleLine | SpaceBetweenSiblings,
        ClassMembers = Indented | MultiLine,
        InterfaceMembers = Indented | MultiLine,
        EnumMembers = CommaDelimited | Indented | MultiLine,
        CaseBlockClauses = Indented | MultiLine,
        NamedImportsOrExportsElements = CommaDelimited | SpaceBetweenSiblings | AllowTrailingComma | SingleLine | SpaceBetweenBraces,
        JsxElementOrFragmentChildren = SingleLine | NoInterveningComments,
        JsxElementAttributes = SingleLine | SpaceBetweenSiblings | NoInterveningComments,
        CaseOrDefaultClauseStatements = Indented | MultiLine | NoTrailingNewLine | OptionalIfEmpty,
        HeritageClauseTypes = CommaDelimited | SpaceBetweenSiblings | SingleLine,
        SourceFileStatements = MultiLine | NoTrailingNewLine,
        Decorators = MultiLine | Optional,
        TypeArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | AngleBrackets | Optional,
        类型参数 = CommaDelimited | SpaceBetweenSiblings | SingleLine | AngleBrackets | Optional,
        参数 = CommaDelimited | SpaceBetweenSiblings | SingleLine | Parenthesis,
        IndexSignature参数 = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | SquareBrackets,
    }

    导出 接口 KlangJson_ {
        名称?: 文字;
        版本?: 文字;
        依赖?: { [x: 文字]: 文字 }
    }

}
